diff --git a/sys/compat/ndis/kern_ndis.c b/sys/compat/ndis/kern_ndis.c index 623cfca49af1..98b9c91562d3 100644 --- a/sys/compat/ndis/kern_ndis.c +++ b/sys/compat/ndis/kern_ndis.c @@ -1,1518 +1,1544 @@ /* * Copyright (c) 2003 * Bill Paul . All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Bill Paul. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "card_if.h" #include #include #include #include #include #include #include #define NDIS_DUMMY_PATH "\\\\some\\bogus\\path" __stdcall static void ndis_status_func(ndis_handle, ndis_status, void *, uint32_t); __stdcall static void ndis_statusdone_func(ndis_handle); __stdcall static void ndis_setdone_func(ndis_handle, ndis_status); __stdcall static void ndis_getdone_func(ndis_handle, ndis_status); __stdcall static void ndis_resetdone_func(ndis_handle, ndis_status, uint8_t); __stdcall static void ndis_sendrsrcavail_func(ndis_handle); struct nd_head ndis_devhead; struct ndis_req { void (*nr_func)(void *); void *nr_arg; int nr_exit; STAILQ_ENTRY(ndis_req) link; }; struct ndisproc { struct ndisqhead *np_q; struct proc *np_p; }; static int ndis_create_kthreads(void); static void ndis_destroy_kthreads(void); static void ndis_stop_thread(int); static int ndis_enlarge_thrqueue(int); static int ndis_shrink_thrqueue(int); static void ndis_runq(void *); extern struct mtx_pool *ndis_mtxpool; static uma_zone_t ndis_packet_zone, ndis_buffer_zone; struct mtx *ndis_thr_mtx; static STAILQ_HEAD(ndisqhead, ndis_req) ndis_ttodo; struct ndisqhead ndis_itodo; struct ndisqhead ndis_free; static int ndis_jobs = 32; static struct ndisproc ndis_tproc; static struct ndisproc ndis_iproc; /* * This allows us to export our symbols to other modules. * Note that we call ourselves 'ndisapi' to avoid a namespace * collision with if_ndis.ko, which internally calls itself * 'ndis.' */ static int ndis_modevent(module_t mod, int cmd, void *arg) { int error = 0; switch (cmd) { case MOD_LOAD: /* Initialize subsystems */ ndis_libinit(); ntoskrnl_libinit(); /* Initialize TX buffer UMA zone. */ ndis_packet_zone = uma_zcreate("NDIS packet", sizeof(ndis_packet), NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0); ndis_buffer_zone = uma_zcreate("NDIS buffer", sizeof(ndis_buffer), NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0); ndis_create_kthreads(); TAILQ_INIT(&ndis_devhead); break; case MOD_SHUTDOWN: /* stop kthreads */ ndis_destroy_kthreads(); if (TAILQ_FIRST(&ndis_devhead) != NULL) { /* Shut down subsystems */ ndis_libfini(); ntoskrnl_libfini(); /* Remove zones */ uma_zdestroy(ndis_packet_zone); uma_zdestroy(ndis_buffer_zone); } break; case MOD_UNLOAD: /* stop kthreads */ ndis_destroy_kthreads(); /* Shut down subsystems */ ndis_libfini(); ntoskrnl_libfini(); /* Remove zones */ uma_zdestroy(ndis_packet_zone); uma_zdestroy(ndis_buffer_zone); break; default: error = EINVAL; break; } return(error); } DEV_MODULE(ndisapi, ndis_modevent, NULL); MODULE_VERSION(ndisapi, 1); /* * We create two kthreads for the NDIS subsystem. One of them is a task * queue for performing various odd jobs. The other is an swi thread * reserved exclusively for running interrupt handlers. The reason we * have our own task queue is that there are some cases where we may * need to sleep for a significant amount of time, and if we were to * use one of the taskqueue threads, we might delay the processing * of other pending tasks which might need to run right away. We have * a separate swi thread because we don't want our interrupt handling * to be delayed either. * * By default there are 32 jobs available to start, and another 8 * are added to the free list each time a new device is created. */ static void ndis_runq(arg) void *arg; { struct ndis_req *r = NULL, *die = NULL; struct ndisproc *p; p = arg; while (1) { kthread_suspend(p->np_p, 0); /* Look for any jobs on the work queue. */ mtx_pool_lock(ndis_mtxpool, ndis_thr_mtx); while(STAILQ_FIRST(p->np_q) != NULL) { r = STAILQ_FIRST(p->np_q); STAILQ_REMOVE_HEAD(p->np_q, link); mtx_pool_unlock(ndis_mtxpool, ndis_thr_mtx); /* Do the work. */ if (r->nr_func != NULL) (*r->nr_func)(r->nr_arg); mtx_pool_lock(ndis_mtxpool, ndis_thr_mtx); STAILQ_INSERT_HEAD(&ndis_free, r, link); /* Check for a shutdown request */ if (r->nr_exit == TRUE) die = r; } mtx_pool_unlock(ndis_mtxpool, ndis_thr_mtx); /* Bail if we were told to shut down. */ if (die != NULL) break; } wakeup(die); mtx_lock(&Giant); kthread_exit(0); } static int ndis_create_kthreads() { struct ndis_req *r; int i, error = 0; ndis_thr_mtx = mtx_pool_alloc(ndis_mtxpool); STAILQ_INIT(&ndis_ttodo); STAILQ_INIT(&ndis_itodo); STAILQ_INIT(&ndis_free); for (i = 0; i < ndis_jobs; i++) { r = malloc(sizeof(struct ndis_req), M_DEVBUF, M_WAITOK); if (r == NULL) { error = ENOMEM; break; } STAILQ_INSERT_HEAD(&ndis_free, r, link); } if (error == 0) { ndis_tproc.np_q = &ndis_ttodo; error = kthread_create(ndis_runq, &ndis_tproc, &ndis_tproc.np_p, RFHIGHPID, 0, "ndis taskqueue"); } if (error == 0) { ndis_iproc.np_q = &ndis_itodo; error = kthread_create(ndis_runq, &ndis_iproc, &ndis_iproc.np_p, RFHIGHPID, 0, "ndis swi"); } if (error) { while ((r = STAILQ_FIRST(&ndis_free)) != NULL) { STAILQ_REMOVE_HEAD(&ndis_free, link); free(r, M_DEVBUF); } return(error); } return(0); } static void ndis_destroy_kthreads() { struct ndis_req *r; /* Stop the threads. */ ndis_stop_thread(NDIS_TASKQUEUE); ndis_stop_thread(NDIS_SWI); /* Destroy request structures. */ while ((r = STAILQ_FIRST(&ndis_free)) != NULL) { STAILQ_REMOVE_HEAD(&ndis_free, link); free(r, M_DEVBUF); } return; } static void ndis_stop_thread(t) int t; { struct ndis_req *r; struct timeval tv; struct ndisqhead *q; struct proc *p; if (t == NDIS_TASKQUEUE) { q = &ndis_ttodo; p = ndis_tproc.np_p; } else { q = &ndis_itodo; p = ndis_iproc.np_p; } /* Create and post a special 'exit' job. */ mtx_pool_lock(ndis_mtxpool, ndis_thr_mtx); r = STAILQ_FIRST(&ndis_free); STAILQ_REMOVE_HEAD(&ndis_free, link); r->nr_func = NULL; r->nr_arg = NULL; r->nr_exit = TRUE; STAILQ_INSERT_TAIL(q, r, link); mtx_pool_unlock(ndis_mtxpool, ndis_thr_mtx); kthread_resume(p); /* wait for thread exit */ tv.tv_sec = 60; tv.tv_usec = 0; tsleep(r, PPAUSE|PCATCH, "ndisthrexit", tvtohz(&tv)); /* Now empty the job list. */ mtx_pool_lock(ndis_mtxpool, ndis_thr_mtx); while ((r = STAILQ_FIRST(q)) != NULL) { STAILQ_REMOVE_HEAD(q, link); STAILQ_INSERT_HEAD(&ndis_free, r, link); } mtx_pool_unlock(ndis_mtxpool, ndis_thr_mtx); return; } static int ndis_enlarge_thrqueue(cnt) int cnt; { struct ndis_req *r; int i; for (i = 0; i < cnt; i++) { r = malloc(sizeof(struct ndis_req), M_DEVBUF, M_WAITOK); if (r == NULL) return(ENOMEM); mtx_pool_lock(ndis_mtxpool, ndis_thr_mtx); STAILQ_INSERT_HEAD(&ndis_free, r, link); ndis_jobs++; mtx_pool_unlock(ndis_mtxpool, ndis_thr_mtx); } return(0); } static int ndis_shrink_thrqueue(cnt) int cnt; { struct ndis_req *r; int i; for (i = 0; i < cnt; i++) { mtx_pool_lock(ndis_mtxpool, ndis_thr_mtx); r = STAILQ_FIRST(&ndis_free); if (r == NULL) { mtx_pool_unlock(ndis_mtxpool, ndis_thr_mtx); return(ENOMEM); } STAILQ_REMOVE_HEAD(&ndis_free, link); ndis_jobs--; mtx_pool_unlock(ndis_mtxpool, ndis_thr_mtx); free(r, M_DEVBUF); } return(0); } int ndis_sched(func, arg, t) void (*func)(void *); void *arg; int t; { struct ndis_req *r; struct ndisqhead *q; struct proc *p; if (t == NDIS_TASKQUEUE) { q = &ndis_ttodo; p = ndis_tproc.np_p; } else { q = &ndis_itodo; p = ndis_iproc.np_p; } mtx_pool_lock(ndis_mtxpool, ndis_thr_mtx); /* * Check to see if an instance of this job is already * pending. If so, don't bother queuing it again. */ STAILQ_FOREACH(r, q, link) { if (r->nr_func == func && r->nr_arg == arg) { mtx_pool_unlock(ndis_mtxpool, ndis_thr_mtx); return(0); } } r = STAILQ_FIRST(&ndis_free); if (r == NULL) { mtx_pool_unlock(ndis_mtxpool, ndis_thr_mtx); return(EAGAIN); } STAILQ_REMOVE_HEAD(&ndis_free, link); r->nr_func = func; r->nr_arg = arg; r->nr_exit = FALSE; STAILQ_INSERT_TAIL(q, r, link); mtx_pool_unlock(ndis_mtxpool, ndis_thr_mtx); /* Post the job. */ kthread_resume(p); return(0); } __stdcall static void ndis_sendrsrcavail_func(adapter) ndis_handle adapter; { return; } __stdcall static void ndis_status_func(adapter, status, sbuf, slen) ndis_handle adapter; ndis_status status; void *sbuf; uint32_t slen; { ndis_miniport_block *block; block = adapter; if (block->nmb_ifp->if_flags & IFF_DEBUG) device_printf (block->nmb_dev, "status: %x\n", status); return; } __stdcall static void ndis_statusdone_func(adapter) ndis_handle adapter; { ndis_miniport_block *block; block = adapter; if (block->nmb_ifp->if_flags & IFF_DEBUG) device_printf (block->nmb_dev, "status complete\n"); return; } __stdcall static void ndis_setdone_func(adapter, status) ndis_handle adapter; ndis_status status; { ndis_miniport_block *block; block = adapter; block->nmb_setstat = status; wakeup(&block->nmb_wkupdpctimer); return; } __stdcall static void ndis_getdone_func(adapter, status) ndis_handle adapter; ndis_status status; { ndis_miniport_block *block; block = adapter; block->nmb_getstat = status; wakeup(&block->nmb_wkupdpctimer); return; } __stdcall static void ndis_resetdone_func(adapter, status, addressingreset) ndis_handle adapter; ndis_status status; uint8_t addressingreset; { ndis_miniport_block *block; block = adapter; if (block->nmb_ifp->if_flags & IFF_DEBUG) device_printf (block->nmb_dev, "reset done...\n"); return; } #define NDIS_AM_RID 3 int ndis_alloc_amem(arg) void *arg; { struct ndis_softc *sc; int error, rid; if (arg == NULL) return(EINVAL); sc = arg; rid = NDIS_AM_RID; sc->ndis_res_am = bus_alloc_resource(sc->ndis_dev, SYS_RES_MEMORY, &rid, 0UL, ~0UL, 0x1000, RF_ACTIVE); if (sc->ndis_res_am == NULL) { device_printf(sc->ndis_dev, "failed to allocate attribute memory\n"); return(ENXIO); } error = CARD_SET_MEMORY_OFFSET(device_get_parent(sc->ndis_dev), sc->ndis_dev, rid, 0, NULL); if (error) { device_printf(sc->ndis_dev, "CARD_SET_MEMORY_OFFSET() returned 0x%x\n", error); return(error); } error = CARD_SET_RES_FLAGS(device_get_parent(sc->ndis_dev), sc->ndis_dev, SYS_RES_MEMORY, rid, PCCARD_A_MEM_ATTR); if (error) { device_printf(sc->ndis_dev, "CARD_SET_RES_FLAGS() returned 0x%x\n", error); return(error); } return(0); } int ndis_create_sysctls(arg) void *arg; { struct ndis_softc *sc; ndis_cfg *vals; char buf[256]; if (arg == NULL) return(EINVAL); sc = arg; vals = sc->ndis_regvals; TAILQ_INIT(&sc->ndis_cfglist_head); /* Create the sysctl tree. */ sc->ndis_tree = SYSCTL_ADD_NODE(&sc->ndis_ctx, SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO, device_get_nameunit(sc->ndis_dev), CTLFLAG_RD, 0, device_get_desc(sc->ndis_dev)); /* Add the driver-specific registry keys. */ vals = sc->ndis_regvals; while(1) { if (vals->nc_cfgkey == NULL) break; if (vals->nc_idx != sc->ndis_devidx) { vals++; continue; } SYSCTL_ADD_STRING(&sc->ndis_ctx, SYSCTL_CHILDREN(sc->ndis_tree), OID_AUTO, vals->nc_cfgkey, CTLFLAG_RW, vals->nc_val, sizeof(vals->nc_val), vals->nc_cfgdesc); vals++; } /* Now add a couple of builtin keys. */ /* * Environment can be either Windows (0) or WindowsNT (1). * We qualify as the latter. */ ndis_add_sysctl(sc, "Environment", "Windows environment", "1", CTLFLAG_RD); /* NDIS version should be 5.1. */ ndis_add_sysctl(sc, "NdisVersion", "NDIS API Version", "0x00050001", CTLFLAG_RD); /* Bus type (PCI, PCMCIA, etc...) */ sprintf(buf, "%d", (int)sc->ndis_iftype); ndis_add_sysctl(sc, "BusType", "Bus Type", buf, CTLFLAG_RD); if (sc->ndis_res_io != NULL) { sprintf(buf, "0x%lx", rman_get_start(sc->ndis_res_io)); ndis_add_sysctl(sc, "IOBaseAddress", "Base I/O Address", buf, CTLFLAG_RD); } if (sc->ndis_irq != NULL) { sprintf(buf, "%lu", rman_get_start(sc->ndis_irq)); ndis_add_sysctl(sc, "InterruptNumber", "Interrupt Number", buf, CTLFLAG_RD); } return(0); } int ndis_add_sysctl(arg, key, desc, val, flag) void *arg; char *key; char *desc; char *val; int flag; { struct ndis_softc *sc; struct ndis_cfglist *cfg; char descstr[256]; sc = arg; cfg = malloc(sizeof(struct ndis_cfglist), M_DEVBUF, M_NOWAIT|M_ZERO); if (cfg == NULL) return(ENOMEM); cfg->ndis_cfg.nc_cfgkey = strdup(key, M_DEVBUF); if (desc == NULL) { snprintf(descstr, sizeof(descstr), "%s (dynamic)", key); cfg->ndis_cfg.nc_cfgdesc = strdup(descstr, M_DEVBUF); } else cfg->ndis_cfg.nc_cfgdesc = strdup(desc, M_DEVBUF); strcpy(cfg->ndis_cfg.nc_val, val); TAILQ_INSERT_TAIL(&sc->ndis_cfglist_head, cfg, link); SYSCTL_ADD_STRING(&sc->ndis_ctx, SYSCTL_CHILDREN(sc->ndis_tree), OID_AUTO, cfg->ndis_cfg.nc_cfgkey, flag, cfg->ndis_cfg.nc_val, sizeof(cfg->ndis_cfg.nc_val), cfg->ndis_cfg.nc_cfgdesc); return(0); } int ndis_flush_sysctls(arg) void *arg; { struct ndis_softc *sc; struct ndis_cfglist *cfg; sc = arg; while (!TAILQ_EMPTY(&sc->ndis_cfglist_head)) { cfg = TAILQ_FIRST(&sc->ndis_cfglist_head); TAILQ_REMOVE(&sc->ndis_cfglist_head, cfg, link); free(cfg->ndis_cfg.nc_cfgkey, M_DEVBUF); free(cfg->ndis_cfg.nc_cfgdesc, M_DEVBUF); free(cfg, M_DEVBUF); } return(0); } void ndis_return_packet(buf, arg) void *buf; /* not used */ void *arg; { struct ndis_softc *sc; ndis_handle adapter; ndis_packet *p; __stdcall ndis_return_handler returnfunc; if (arg == NULL) return; p = arg; /* Decrement refcount. */ p->np_refcnt--; /* Release packet when refcount hits zero, otherwise return. */ if (p->np_refcnt) return; sc = p->np_softc; returnfunc = sc->ndis_chars.nmc_return_packet_func; adapter = sc->ndis_block.nmb_miniportadapterctx; if (returnfunc != NULL) returnfunc(adapter, p); return; } void ndis_free_bufs(b0) ndis_buffer *b0; { ndis_buffer *next; if (b0 == NULL) return; while(b0 != NULL) { next = b0->nb_next; uma_zfree (ndis_buffer_zone, b0); b0 = next; } return; } void ndis_free_packet(p) ndis_packet *p; { if (p == NULL) return; ndis_free_bufs(p->np_private.npp_head); uma_zfree(ndis_packet_zone, p); return; } int ndis_convert_res(arg) void *arg; { struct ndis_softc *sc; ndis_resource_list *rl = NULL; cm_partial_resource_desc *prd = NULL; ndis_miniport_block *block; device_t dev; struct resource_list *brl; struct resource_list_entry *brle; sc = arg; block = &sc->ndis_block; dev = sc->ndis_dev; rl = malloc(sizeof(ndis_resource_list) + (sizeof(cm_partial_resource_desc) * (sc->ndis_rescnt - 1)), M_DEVBUF, M_NOWAIT|M_ZERO); if (rl == NULL) return(ENOMEM); rl->cprl_version = 5; rl->cprl_version = 1; rl->cprl_count = sc->ndis_rescnt; prd = rl->cprl_partial_descs; brl = BUS_GET_RESOURCE_LIST(device_get_parent(dev), dev); if (brl != NULL) { SLIST_FOREACH(brle, brl, link) { switch (brle->type) { case SYS_RES_IOPORT: prd->cprd_type = CmResourceTypePort; prd->u.cprd_port.cprd_start.np_quad = brle->start; prd->u.cprd_port.cprd_len = brle->count; break; case SYS_RES_MEMORY: prd->cprd_type = CmResourceTypeMemory; prd->u.cprd_port.cprd_start.np_quad = brle->start; prd->u.cprd_port.cprd_len = brle->count; break; case SYS_RES_IRQ: prd->cprd_type = CmResourceTypeInterrupt; prd->u.cprd_intr.cprd_level = brle->start; prd->u.cprd_intr.cprd_vector = brle->start; prd->u.cprd_intr.cprd_affinity = 0; break; default: break; } prd++; } } block->nmb_rlist = rl; return(0); } /* * Map an NDIS packet to an mbuf list. When an NDIS driver receives a * packet, it will hand it to us in the form of an ndis_packet, * which we need to convert to an mbuf that is then handed off * to the stack. Note: we configure the mbuf list so that it uses * the memory regions specified by the ndis_buffer structures in * the ndis_packet as external storage. In most cases, this will * point to a memory region allocated by the driver (either by * ndis_malloc_withtag() or ndis_alloc_sharedmem()). We expect * the driver to handle free()ing this region for is, so we set up * a dummy no-op free handler for it. */ int ndis_ptom(m0, p) struct mbuf **m0; ndis_packet *p; { struct mbuf *m, *prev = NULL; ndis_buffer *buf; ndis_packet_private *priv; uint32_t totlen = 0; if (p == NULL || m0 == NULL) return(EINVAL); priv = &p->np_private; buf = priv->npp_head; p->np_refcnt = 0; for (buf = priv->npp_head; buf != NULL; buf = buf->nb_next) { if (buf == priv->npp_head) MGETHDR(m, M_DONTWAIT, MT_HEADER); else MGET(m, M_DONTWAIT, MT_DATA); if (m == NULL) { m_freem(*m0); *m0 = NULL; return(ENOBUFS); } m->m_len = buf->nb_bytecount; m->m_data = MDL_VA(buf); MEXTADD(m, m->m_data, m->m_len, ndis_return_packet, p, 0, EXT_NDIS); p->np_refcnt++; totlen += m->m_len; if (m->m_flags & MT_HEADER) *m0 = m; else prev->m_next = m; prev = m; } (*m0)->m_pkthdr.len = totlen; return(0); } /* * Create an mbuf chain from an NDIS packet chain. * This is used mainly when transmitting packets, where we need * to turn an mbuf off an interface's send queue and transform it * into an NDIS packet which will be fed into the NDIS driver's * send routine. * * NDIS packets consist of two parts: an ndis_packet structure, * which is vaguely analagous to the pkthdr portion of an mbuf, * and one or more ndis_buffer structures, which define the * actual memory segments in which the packet data resides. * We need to allocate one ndis_buffer for each mbuf in a chain, * plus one ndis_packet as the header. */ int ndis_mtop(m0, p) struct mbuf *m0; ndis_packet **p; { struct mbuf *m; ndis_buffer *buf = NULL, *prev = NULL; ndis_packet_private *priv; if (p == NULL || m0 == NULL) return(EINVAL); /* If caller didn't supply a packet, make one. */ if (*p == NULL) { *p = uma_zalloc(ndis_packet_zone, M_NOWAIT|M_ZERO); if (*p == NULL) return(ENOMEM); } priv = &(*p)->np_private; priv->npp_totlen = m0->m_pkthdr.len; priv->npp_packetooboffset = offsetof(ndis_packet, np_oob); priv->npp_ndispktflags = NDIS_PACKET_ALLOCATED_BY_NDIS; for (m = m0; m != NULL; m = m->m_next) { if (m->m_len == 0) continue; buf = uma_zalloc(ndis_buffer_zone, M_NOWAIT | M_ZERO); if (buf == NULL) { ndis_free_packet(*p); *p = NULL; return(ENOMEM); } MDL_INIT(buf, m->m_data, m->m_len); if (priv->npp_head == NULL) priv->npp_head = buf; else prev->nb_next = buf; prev = buf; } priv->npp_tail = buf; priv->npp_totlen = m0->m_pkthdr.len; return(0); } int ndis_get_supported_oids(arg, oids, oidcnt) void *arg; ndis_oid **oids; int *oidcnt; { int len, rval; ndis_oid *o; if (arg == NULL || oids == NULL || oidcnt == NULL) return(EINVAL); len = 0; ndis_get_info(arg, OID_GEN_SUPPORTED_LIST, NULL, &len); o = malloc(len, M_DEVBUF, M_NOWAIT); if (o == NULL) return(ENOMEM); rval = ndis_get_info(arg, OID_GEN_SUPPORTED_LIST, o, &len); if (rval) { free(o, M_DEVBUF); return(rval); } *oids = o; *oidcnt = len / 4; return(0); } int ndis_set_info(arg, oid, buf, buflen) void *arg; ndis_oid oid; void *buf; int *buflen; { struct ndis_softc *sc; ndis_status rval; ndis_handle adapter; __stdcall ndis_setinfo_handler setfunc; uint32_t byteswritten = 0, bytesneeded = 0; struct timeval tv; int error; sc = arg; setfunc = sc->ndis_chars.nmc_setinfo_func; adapter = sc->ndis_block.nmb_miniportadapterctx; rval = setfunc(adapter, oid, buf, *buflen, &byteswritten, &bytesneeded); if (rval == NDIS_STATUS_PENDING) { tv.tv_sec = 60; tv.tv_usec = 0; error = tsleep(&sc->ndis_block.nmb_wkupdpctimer, PPAUSE|PCATCH, "ndisset", tvtohz(&tv)); rval = sc->ndis_block.nmb_setstat; } if (byteswritten) *buflen = byteswritten; if (bytesneeded) *buflen = bytesneeded; if (rval == NDIS_STATUS_INVALID_LENGTH) return(ENOSPC); if (rval == NDIS_STATUS_INVALID_OID) return(EINVAL); if (rval == NDIS_STATUS_NOT_SUPPORTED || rval == NDIS_STATUS_NOT_ACCEPTED) return(ENOTSUP); if (rval != NDIS_STATUS_SUCCESS) return(ENODEV); return(0); } typedef void (*ndis_senddone_func)(ndis_handle, ndis_packet *, ndis_status); int ndis_send_packets(arg, packets, cnt) void *arg; ndis_packet **packets; int cnt; { struct ndis_softc *sc; ndis_handle adapter; __stdcall ndis_sendmulti_handler sendfunc; __stdcall ndis_senddone_func senddonefunc; int i; ndis_packet *p; sc = arg; adapter = sc->ndis_block.nmb_miniportadapterctx; sendfunc = sc->ndis_chars.nmc_sendmulti_func; senddonefunc = sc->ndis_block.nmb_senddone_func; sendfunc(adapter, packets, cnt); for (i = 0; i < cnt; i++) { p = packets[i]; /* * Either the driver already handed the packet to * ndis_txeof() due to a failure, or it wants to keep * it and release it asynchronously later. Skip to the * next one. */ if (p == NULL || p->np_oob.npo_status == NDIS_STATUS_PENDING) continue; senddonefunc(&sc->ndis_block, p, p->np_oob.npo_status); } return(0); } +int +ndis_send_packet(arg, packet) + void *arg; + ndis_packet *packet; +{ + struct ndis_softc *sc; + ndis_handle adapter; + ndis_status status; + __stdcall ndis_sendsingle_handler sendfunc; + __stdcall ndis_senddone_func senddonefunc; + + sc = arg; + adapter = sc->ndis_block.nmb_miniportadapterctx; + sendfunc = sc->ndis_chars.nmc_sendsingle_func; + senddonefunc = sc->ndis_block.nmb_senddone_func; + + status = sendfunc(adapter, packet, packet->np_private.npp_flags); + + if (status == NDIS_STATUS_PENDING) + return(0); + + senddonefunc(&sc->ndis_block, packet, status); + + return(0); +} + int ndis_init_dma(arg) void *arg; { struct ndis_softc *sc; int i, error; sc = arg; sc->ndis_tmaps = malloc(sizeof(bus_dmamap_t) * sc->ndis_maxpkts, M_DEVBUF, M_NOWAIT|M_ZERO); if (sc->ndis_tmaps == NULL) return(ENOMEM); for (i = 0; i < sc->ndis_maxpkts; i++) { error = bus_dmamap_create(sc->ndis_ttag, 0, &sc->ndis_tmaps[i]); if (error) { free(sc->ndis_tmaps, M_DEVBUF); return(ENODEV); } } return(0); } int ndis_destroy_dma(arg) void *arg; { struct ndis_softc *sc; struct mbuf *m; ndis_packet *p = NULL; int i; sc = arg; for (i = 0; i < sc->ndis_maxpkts; i++) { if (sc->ndis_txarray[i] != NULL) { p = sc->ndis_txarray[i]; m = (struct mbuf *)p->np_rsvd[1]; if (m != NULL) m_freem(m); ndis_free_packet(sc->ndis_txarray[i]); } bus_dmamap_destroy(sc->ndis_ttag, sc->ndis_tmaps[i]); } free(sc->ndis_tmaps, M_DEVBUF); bus_dma_tag_destroy(sc->ndis_ttag); return(0); } int ndis_reset_nic(arg) void *arg; { struct ndis_softc *sc; ndis_handle adapter; __stdcall ndis_reset_handler resetfunc; uint8_t addressing_reset; struct ifnet *ifp; sc = arg; ifp = &sc->arpcom.ac_if; adapter = sc->ndis_block.nmb_miniportadapterctx; if (adapter == NULL) return(EIO); resetfunc = sc->ndis_chars.nmc_reset_func; if (resetfunc == NULL) return(EINVAL); resetfunc(&addressing_reset, adapter); return(0); } int ndis_halt_nic(arg) void *arg; { struct ndis_softc *sc; ndis_handle adapter; __stdcall ndis_halt_handler haltfunc; struct ifnet *ifp; struct ndis_timer_entry *ne; sc = arg; ifp = &sc->arpcom.ac_if; adapter = sc->ndis_block.nmb_miniportadapterctx; if (adapter == NULL) return(EIO); haltfunc = sc->ndis_chars.nmc_halt_func; if (haltfunc == NULL) return(EINVAL); haltfunc(adapter); /* * The adapter context is only valid after the init * handler has been called, and is invalid once the * halt handler has been called. */ sc->ndis_block.nmb_miniportadapterctx = NULL; /* Clobber all the timers in case the driver left one running. */ while (!TAILQ_EMPTY(&sc->ndis_block.nmb_timerlist)) { ne = TAILQ_FIRST(&sc->ndis_block.nmb_timerlist); TAILQ_REMOVE(&sc->ndis_block.nmb_timerlist, ne, link); callout_stop(&ne->nte_ch); free(ne, M_DEVBUF); } return(0); } int ndis_shutdown_nic(arg) void *arg; { struct ndis_softc *sc; ndis_handle adapter; __stdcall ndis_shutdown_handler shutdownfunc; sc = arg; adapter = sc->ndis_block.nmb_miniportadapterctx; if (adapter == NULL) return(EIO); shutdownfunc = sc->ndis_chars.nmc_shutdown_handler; if (shutdownfunc == NULL) return(EINVAL); if (sc->ndis_chars.nmc_rsvd0 == NULL) shutdownfunc(adapter); else shutdownfunc(sc->ndis_chars.nmc_rsvd0); ndis_shrink_thrqueue(8); TAILQ_REMOVE(&ndis_devhead, &sc->ndis_block, link); return(0); } int ndis_init_nic(arg) void *arg; { struct ndis_softc *sc; ndis_miniport_block *block; __stdcall ndis_init_handler initfunc; ndis_status status, openstatus = 0; ndis_medium mediumarray[NdisMediumMax]; uint32_t chosenmedium, i; if (arg == NULL) return(EINVAL); sc = arg; block = &sc->ndis_block; initfunc = sc->ndis_chars.nmc_init_func; TAILQ_INIT(&block->nmb_timerlist); for (i = 0; i < NdisMediumMax; i++) mediumarray[i] = i; status = initfunc(&openstatus, &chosenmedium, mediumarray, NdisMediumMax, block, block); /* * If the init fails, blow away the other exported routines * we obtained from the driver so we can't call them later. * If the init failed, none of these will work. */ if (status != NDIS_STATUS_SUCCESS) { bzero((char *)&sc->ndis_chars, sizeof(ndis_miniport_characteristics)); return(ENXIO); } return(0); } void ndis_enable_intr(arg) void *arg; { struct ndis_softc *sc; ndis_handle adapter; __stdcall ndis_enable_interrupts_handler intrenbfunc; sc = arg; adapter = sc->ndis_block.nmb_miniportadapterctx; if (adapter == NULL) return; intrenbfunc = sc->ndis_chars.nmc_enable_interrupts_func; if (intrenbfunc == NULL) return; intrenbfunc(adapter); return; } void ndis_disable_intr(arg) void *arg; { struct ndis_softc *sc; ndis_handle adapter; __stdcall ndis_disable_interrupts_handler intrdisfunc; sc = arg; adapter = sc->ndis_block.nmb_miniportadapterctx; if (adapter == NULL) return; intrdisfunc = sc->ndis_chars.nmc_disable_interrupts_func; if (intrdisfunc == NULL) return; intrdisfunc(adapter); return; } int ndis_isr(arg, ourintr, callhandler) void *arg; int *ourintr; int *callhandler; { struct ndis_softc *sc; ndis_handle adapter; __stdcall ndis_isr_handler isrfunc; uint8_t accepted, queue; if (arg == NULL || ourintr == NULL || callhandler == NULL) return(EINVAL); sc = arg; adapter = sc->ndis_block.nmb_miniportadapterctx; isrfunc = sc->ndis_chars.nmc_isr_func; isrfunc(&accepted, &queue, adapter); *ourintr = accepted; *callhandler = queue; return(0); } int ndis_intrhand(arg) void *arg; { struct ndis_softc *sc; ndis_handle adapter; __stdcall ndis_interrupt_handler intrfunc; if (arg == NULL) return(EINVAL); sc = arg; adapter = sc->ndis_block.nmb_miniportadapterctx; intrfunc = sc->ndis_chars.nmc_interrupt_func; intrfunc(adapter); return(0); } int ndis_get_info(arg, oid, buf, buflen) void *arg; ndis_oid oid; void *buf; int *buflen; { struct ndis_softc *sc; ndis_status rval; ndis_handle adapter; __stdcall ndis_queryinfo_handler queryfunc; uint32_t byteswritten = 0, bytesneeded = 0; struct timeval tv; int error; sc = arg; queryfunc = sc->ndis_chars.nmc_queryinfo_func; adapter = sc->ndis_block.nmb_miniportadapterctx; rval = queryfunc(adapter, oid, buf, *buflen, &byteswritten, &bytesneeded); /* Wait for requests that block. */ if (rval == NDIS_STATUS_PENDING) { tv.tv_sec = 60; tv.tv_usec = 0; error = tsleep(&sc->ndis_block.nmb_wkupdpctimer, PPAUSE|PCATCH, "ndisget", tvtohz(&tv)); rval = sc->ndis_block.nmb_getstat; } if (byteswritten) *buflen = byteswritten; if (bytesneeded) *buflen = bytesneeded; if (rval == NDIS_STATUS_INVALID_LENGTH || rval == NDIS_STATUS_BUFFER_TOO_SHORT) return(ENOSPC); if (rval == NDIS_STATUS_INVALID_OID) return(EINVAL); if (rval == NDIS_STATUS_NOT_SUPPORTED || rval == NDIS_STATUS_NOT_ACCEPTED) return(ENOTSUP); if (rval != NDIS_STATUS_SUCCESS) return(ENODEV); return(0); } int ndis_unload_driver(arg) void *arg; { struct ndis_softc *sc; sc = arg; free(sc->ndis_block.nmb_rlist, M_DEVBUF); ndis_flush_sysctls(sc); ndis_shrink_thrqueue(8); TAILQ_REMOVE(&ndis_devhead, &sc->ndis_block, link); return(0); } #define NDIS_LOADED 0x42534F44 int ndis_load_driver(img, arg) vm_offset_t img; void *arg; { __stdcall driver_entry entry; image_optional_header opt_hdr; image_import_descriptor imp_desc; ndis_unicode_string dummystr; ndis_driver_object drv; ndis_miniport_block *block; ndis_status status; int idx; uint32_t *ptr; struct ndis_softc *sc; sc = arg; /* * Only perform the relocation/linking phase once * since the binary image may be shared among multiple * device instances. */ ptr = (uint32_t *)(img + 8); if (*ptr != NDIS_LOADED) { /* Perform text relocation */ if (pe_relocate(img)) return(ENOEXEC); /* Dynamically link the NDIS.SYS routines -- required. */ if (pe_patch_imports(img, "NDIS", ndis_functbl)) return(ENOEXEC); /* Dynamically link the HAL.dll routines -- also required. */ if (pe_patch_imports(img, "HAL", hal_functbl)) return(ENOEXEC); /* Dynamically link ntoskrnl.exe -- optional. */ if (pe_get_import_descriptor(img, &imp_desc, "ntoskrnl") == 0) { if (pe_patch_imports(img, "ntoskrnl", ntoskrnl_functbl)) return(ENOEXEC); } *ptr = NDIS_LOADED; } /* Locate the driver entry point */ pe_get_optional_header(img, &opt_hdr); entry = (driver_entry)pe_translate_addr(img, opt_hdr.ioh_entryaddr); /* * Now call the DriverEntry() routine. This will cause * a callout to the NdisInitializeWrapper() and * NdisMRegisterMiniport() routines. */ dummystr.nus_len = strlen(NDIS_DUMMY_PATH); dummystr.nus_maxlen = strlen(NDIS_DUMMY_PATH); dummystr.nus_buf = NULL; ndis_ascii_to_unicode(NDIS_DUMMY_PATH, &dummystr.nus_buf); drv.ndo_ifname = "ndis0"; status = entry(&drv, &dummystr); free (dummystr.nus_buf, M_DEVBUF); if (status != NDIS_STATUS_SUCCESS) return(ENODEV); /* * Now that we have the miniport driver characteristics, * create an NDIS block and call the init handler. * This will cause the driver to try to probe for * a device. */ block = &sc->ndis_block; bcopy((char *)&drv.ndo_chars, (char *)&sc->ndis_chars, sizeof(ndis_miniport_characteristics)); /*block->nmb_signature = 0xcafebabe;*/ ptr = (uint32_t *)block; for (idx = 0; idx < sizeof(ndis_miniport_block) / 4; idx++) { *ptr = idx | 0xdead0000; ptr++; } block->nmb_signature = (void *)0xcafebabe; block->nmb_setdone_func = ndis_setdone_func; block->nmb_querydone_func = ndis_getdone_func; block->nmb_status_func = ndis_status_func; block->nmb_statusdone_func = ndis_statusdone_func; block->nmb_resetdone_func = ndis_resetdone_func; block->nmb_sendrsrc_func = ndis_sendrsrcavail_func; block->nmb_ifp = &sc->arpcom.ac_if; block->nmb_dev = sc->ndis_dev; block->nmb_img = img; ndis_enlarge_thrqueue(8); TAILQ_INSERT_TAIL(&ndis_devhead, block, link); return(0); } diff --git a/sys/compat/ndis/subr_ndis.c b/sys/compat/ndis/subr_ndis.c index 9f7df864a745..b7558ef8fabc 100644 --- a/sys/compat/ndis/subr_ndis.c +++ b/sys/compat/ndis/subr_ndis.c @@ -1,2833 +1,2843 @@ /* * Copyright (c) 2003 * Bill Paul . All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Bill Paul. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); /* * This file implements a translation layer between the BSD networking * infrasturcture and Windows(R) NDIS network driver modules. A Windows * NDIS driver calls into several functions in the NDIS.SYS Windows * kernel module and exports a table of functions designed to be called * by the NDIS subsystem. Using the PE loader, we can patch our own * versions of the NDIS routines into a given Windows driver module and * convince the driver that it is in fact running on Windows. * * We provide a table of all our implemented NDIS routines which is patched * into the driver object code. All our exported routines must use the * _stdcall calling convention, since that's what the Windows object code * expects. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define FUNC void(*)(void) static struct mtx *ndis_interlock; static char ndis_filepath[MAXPATHLEN]; struct mtx_pool *ndis_mtxpool; extern struct nd_head ndis_devhead; SYSCTL_STRING(_hw, OID_AUTO, ndis_filepath, CTLFLAG_RW, ndis_filepath, MAXPATHLEN, "Path used by NdisOpenFile() to search for files"); __stdcall static void ndis_initwrap(ndis_handle, ndis_driver_object *, void *, void *); __stdcall static ndis_status ndis_register_miniport(ndis_handle, ndis_miniport_characteristics *, int); __stdcall static ndis_status ndis_malloc_withtag(void **, uint32_t, uint32_t); __stdcall static ndis_status ndis_malloc(void **, uint32_t, uint32_t, ndis_physaddr); __stdcall static void ndis_free(void *, uint32_t, uint32_t); __stdcall static ndis_status ndis_setattr_ex(ndis_handle, ndis_handle, uint32_t, uint32_t, ndis_interface_type); __stdcall static void ndis_open_cfg(ndis_status *, ndis_handle *, ndis_handle); __stdcall static void ndis_open_cfgbyidx(ndis_status *, ndis_handle, uint32_t, ndis_unicode_string *, ndis_handle *); __stdcall static void ndis_open_cfgbyname(ndis_status *, ndis_handle, ndis_unicode_string *, ndis_handle *); static ndis_status ndis_encode_parm(ndis_miniport_block *, struct sysctl_oid *, ndis_parm_type, ndis_config_parm **); static ndis_status ndis_decode_parm(ndis_miniport_block *, ndis_config_parm *, char *); __stdcall static void ndis_read_cfg(ndis_status *, ndis_config_parm **, ndis_handle, ndis_unicode_string *, ndis_parm_type); __stdcall static void ndis_write_cfg(ndis_status *, ndis_handle, ndis_unicode_string *, ndis_config_parm *); __stdcall static void ndis_close_cfg(ndis_handle); __stdcall static void ndis_create_lock(ndis_spin_lock *); __stdcall static void ndis_destroy_lock(ndis_spin_lock *); __stdcall static void ndis_lock(ndis_spin_lock *); __stdcall static void ndis_unlock(ndis_spin_lock *); __stdcall static uint32_t ndis_read_pci(ndis_handle, uint32_t, uint32_t, void *, uint32_t); __stdcall static uint32_t ndis_write_pci(ndis_handle, uint32_t, uint32_t, void *, uint32_t); static void ndis_syslog(ndis_handle, ndis_error_code, uint32_t, ...); static void ndis_map_cb(void *, bus_dma_segment_t *, int, int); __stdcall static void ndis_vtophys_load(ndis_handle, ndis_buffer *, uint32_t, uint8_t, ndis_paddr_unit *, uint32_t *); __stdcall static void ndis_vtophys_unload(ndis_handle, ndis_buffer *, uint32_t); __stdcall static void ndis_create_timer(ndis_miniport_timer *, ndis_handle *, ndis_timer_function, void *); __stdcall static void ndis_init_timer(ndis_timer *, ndis_timer_function, void *); static void ndis_timercall(void *); __stdcall static void ndis_set_timer(ndis_miniport_timer *, uint32_t); static void ndis_tick(void *); __stdcall static void ndis_set_periodic_timer(ndis_miniport_timer *, uint32_t); __stdcall static void ndis_cancel_timer(ndis_miniport_timer *, uint8_t *); __stdcall static void ndis_query_resources(ndis_status *, ndis_handle, ndis_resource_list *, uint32_t *); __stdcall static ndis_status ndis_register_ioport(void **, ndis_handle, uint32_t, uint32_t); __stdcall static void ndis_deregister_ioport(ndis_handle, uint32_t, uint32_t, void *); __stdcall static void ndis_read_netaddr(ndis_status *, void **, uint32_t *, ndis_handle); __stdcall static ndis_status ndis_mapreg_cnt(uint32_t, uint32_t *); __stdcall static ndis_status ndis_alloc_mapreg(ndis_handle, uint32_t, uint8_t, uint32_t, uint32_t); __stdcall static void ndis_free_mapreg(ndis_handle); static void ndis_mapshared_cb(void *, bus_dma_segment_t *, int, int); __stdcall static void ndis_alloc_sharedmem(ndis_handle, uint32_t, uint8_t, void **, ndis_physaddr *); __stdcall static void ndis_alloc_sharedmem_async(ndis_handle, uint32_t, uint8_t, void *); __stdcall static void ndis_free_sharedmem(ndis_handle, uint32_t, uint8_t, void *, ndis_physaddr); __stdcall static ndis_status ndis_map_iospace(void **, ndis_handle, ndis_physaddr, uint32_t); __stdcall static void ndis_unmap_iospace(ndis_handle, void *, uint32_t); __stdcall static uint32_t ndis_cachefill(void); __stdcall static uint32_t ndis_dma_align(ndis_handle); __stdcall static ndis_status ndis_init_sc_dma(ndis_handle, uint8_t, uint32_t); __stdcall static void ndis_alloc_packetpool(ndis_status *, ndis_handle *, uint32_t, uint32_t); __stdcall static void ndis_ex_alloc_packetpool(ndis_status *, ndis_handle *, uint32_t, uint32_t, uint32_t); __stdcall static uint32_t ndis_packetpool_use(ndis_handle); __stdcall static void ndis_free_packetpool(ndis_handle); __stdcall static void ndis_alloc_packet(ndis_status *, ndis_packet **, ndis_handle); __stdcall static void ndis_release_packet(ndis_packet *); __stdcall static void ndis_unchain_headbuf(ndis_packet *, ndis_buffer **); __stdcall static void ndis_unchain_tailbuf(ndis_packet *, ndis_buffer **); __stdcall static void ndis_alloc_bufpool(ndis_status *, ndis_handle *, uint32_t); __stdcall static void ndis_free_bufpool(ndis_handle); __stdcall static void ndis_alloc_buf(ndis_status *, ndis_buffer **, ndis_handle, void *, uint32_t); __stdcall static void ndis_release_buf(ndis_buffer *); __stdcall static uint32_t ndis_buflen(ndis_buffer *); __stdcall static void ndis_query_buf(ndis_buffer *, void **, uint32_t *); __stdcall static void ndis_query_buf_safe(ndis_buffer *, void **, uint32_t *, uint32_t); __stdcall static void *ndis_buf_vaddr(ndis_buffer *); __stdcall static void *ndis_buf_vaddr_safe(ndis_buffer *, uint32_t); __stdcall static void ndis_adjust_buflen(ndis_buffer *, int); __stdcall static uint32_t ndis_interlock_inc(uint32_t *); __stdcall static uint32_t ndis_interlock_dec(uint32_t *); __stdcall static void ndis_init_event(ndis_event *); __stdcall static void ndis_set_event(ndis_event *); __stdcall static void ndis_reset_event(ndis_event *); __stdcall static uint8_t ndis_wait_event(ndis_event *, uint32_t); __stdcall static ndis_status ndis_unicode2ansi(ndis_ansi_string *, ndis_unicode_string *); __stdcall static ndis_status ndis_ansi2unicode(ndis_unicode_string *, ndis_ansi_string *); __stdcall static ndis_status ndis_assign_pcirsrc(ndis_handle, uint32_t, ndis_resource_list **); __stdcall static ndis_status ndis_register_intr(ndis_miniport_interrupt *, ndis_handle, uint32_t, uint32_t, uint8_t, uint8_t, ndis_interrupt_mode); __stdcall static void ndis_deregister_intr(ndis_miniport_interrupt *); __stdcall static void ndis_register_shutdown(ndis_handle, void *, ndis_shutdown_handler); __stdcall static void ndis_deregister_shutdown(ndis_handle); __stdcall static uint32_t ndis_numpages(ndis_buffer *); __stdcall static void ndis_buf_physpages(ndis_buffer *, uint32_t *); __stdcall static void ndis_query_bufoffset(ndis_buffer *, uint32_t *, uint32_t *); __stdcall static void ndis_sleep(uint32_t); __stdcall static uint32_t ndis_read_pccard_amem(ndis_handle, uint32_t, void *, uint32_t); __stdcall static uint32_t ndis_write_pccard_amem(ndis_handle, uint32_t, void *, uint32_t); __stdcall static ndis_list_entry *ndis_insert_head(ndis_list_entry *, ndis_list_entry *, ndis_spin_lock *); __stdcall static ndis_list_entry *ndis_remove_head(ndis_list_entry *, ndis_spin_lock *); __stdcall static ndis_list_entry *ndis_insert_tail(ndis_list_entry *, ndis_list_entry *, ndis_spin_lock *); __stdcall static uint8_t ndis_sync_with_intr(ndis_miniport_interrupt *, void *, void *); __stdcall static void ndis_time(uint64_t *); __stdcall static void ndis_uptime(uint32_t *); __stdcall static void ndis_init_string(ndis_unicode_string *, char *); __stdcall static void ndis_init_ansi_string(ndis_ansi_string *, char *); __stdcall static void ndis_init_unicode_string(ndis_unicode_string *, uint16_t *); __stdcall static void ndis_free_string(ndis_unicode_string *); __stdcall static ndis_status ndis_remove_miniport(ndis_handle *); __stdcall static void ndis_termwrap(ndis_handle, void *); __stdcall static void ndis_get_devprop(ndis_handle, void *, void *, void *, cm_resource_list *, cm_resource_list *); __stdcall static void ndis_firstbuf(ndis_packet *, ndis_buffer **, void **, uint32_t *, uint32_t *); __stdcall static void ndis_firstbuf_safe(ndis_packet *, ndis_buffer **, void **, uint32_t *, uint32_t *, uint32_t); __stdcall static void ndis_open_file(ndis_status *, ndis_handle *, uint32_t *, ndis_unicode_string *, ndis_physaddr); __stdcall static void ndis_map_file(ndis_status *, void **, ndis_handle); __stdcall static void ndis_unmap_file(ndis_handle); __stdcall static void ndis_close_file(ndis_handle); __stdcall static u_int8_t ndis_cpu_cnt(void); __stdcall static void ndis_ind_statusdone(ndis_handle); __stdcall static void ndis_ind_status(ndis_handle, ndis_status, void *, uint32_t); static void ndis_workfunc(void *); __stdcall static ndis_status ndis_sched_workitem(ndis_work_item *); __stdcall static void ndis_pkt_to_pkt(ndis_packet *, uint32_t, uint32_t, ndis_packet *, uint32_t, uint32_t *); __stdcall static void ndis_pkt_to_pkt_safe(ndis_packet *, uint32_t, uint32_t, ndis_packet *, uint32_t, uint32_t *, uint32_t); __stdcall static ndis_status ndis_register_dev(ndis_handle *, ndis_unicode_string *, ndis_unicode_string *, void *, void *, ndis_handle **); __stdcall static ndis_status ndis_deregister_dev(ndis_handle *); __stdcall static void dummy(void); /* * Some really old drivers do not properly check the return value * from NdisAllocatePacket() and NdisAllocateBuffer() and will * sometimes allocate few more buffers/packets that they originally * requested when they created the pool. To prevent this from being * a problem, we allocate a few extra buffers/packets beyond what * the driver asks for. This #define controls how many. */ #define NDIS_POOL_EXTRA 16 int ndis_libinit() { strcpy(ndis_filepath, "/compat/ndis"); ndis_mtxpool = mtx_pool_create("ndis mutex pool", 1024, MTX_DEF | MTX_RECURSE | MTX_DUPOK);; ndis_interlock = mtx_pool_alloc(ndis_mtxpool); return(0); } int ndis_libfini() { mtx_pool_destroy(&ndis_mtxpool); return(0); } /* * NDIS deals with strings in unicode format, so we have * do deal with them that way too. For now, we only handle * conversion between unicode and ASCII since that's all * that device drivers care about. */ int ndis_ascii_to_unicode(ascii, unicode) char *ascii; uint16_t **unicode; { uint16_t *ustr; int i; if (*unicode == NULL) *unicode = malloc(strlen(ascii) * 2, M_DEVBUF, M_WAITOK); if (*unicode == NULL) return(ENOMEM); ustr = *unicode; for (i = 0; i < strlen(ascii); i++) { *ustr = (uint16_t)ascii[i]; ustr++; } return(0); } int ndis_unicode_to_ascii(unicode, ulen, ascii) uint16_t *unicode; int ulen; char **ascii; { uint8_t *astr; int i; if (*ascii == NULL) *ascii = malloc((ulen / 2) + 1, M_DEVBUF, M_WAITOK|M_ZERO); if (*ascii == NULL) return(ENOMEM); astr = *ascii; for (i = 0; i < ulen / 2; i++) { *astr = (uint8_t)unicode[i]; astr++; } return(0); } __stdcall static void ndis_initwrap(wrapper, drv_obj, path, unused) ndis_handle wrapper; ndis_driver_object *drv_obj; void *path; void *unused; { ndis_driver_object **drv; drv = wrapper; *drv = drv_obj; return; } __stdcall static void ndis_termwrap(handle, syspec) ndis_handle handle; void *syspec; { return; } __stdcall static ndis_status ndis_register_miniport(handle, characteristics, len) ndis_handle handle; ndis_miniport_characteristics *characteristics; int len; { ndis_driver_object *drv; drv = handle; bcopy((char *)characteristics, (char *)&drv->ndo_chars, sizeof(ndis_miniport_characteristics)); return(NDIS_STATUS_SUCCESS); } __stdcall static ndis_status ndis_malloc_withtag(vaddr, len, tag) void **vaddr; uint32_t len; uint32_t tag; { void *mem; mem = malloc(len, M_DEVBUF, M_NOWAIT); if (mem == NULL) return(NDIS_STATUS_RESOURCES); *vaddr = mem; return(NDIS_STATUS_SUCCESS); } __stdcall static ndis_status ndis_malloc(vaddr, len, flags, highaddr) void **vaddr; uint32_t len; uint32_t flags; ndis_physaddr highaddr; { void *mem; mem = malloc(len, M_DEVBUF, M_NOWAIT); if (mem == NULL) return(NDIS_STATUS_RESOURCES); *vaddr = mem; return(NDIS_STATUS_SUCCESS); } __stdcall static void ndis_free(vaddr, len, flags) void *vaddr; uint32_t len; uint32_t flags; { if (len == 0) return; free(vaddr, M_DEVBUF); return; } __stdcall static ndis_status ndis_setattr_ex(adapter_handle, adapter_ctx, hangsecs, flags, iftype) ndis_handle adapter_handle; ndis_handle adapter_ctx; uint32_t hangsecs; uint32_t flags; ndis_interface_type iftype; { ndis_miniport_block *block; /* * Save the adapter context, we need it for calling * the driver's internal functions. */ block = (ndis_miniport_block *)adapter_handle; block->nmb_miniportadapterctx = adapter_ctx; block->nmb_checkforhangsecs = hangsecs; return(NDIS_STATUS_SUCCESS); } __stdcall static void ndis_open_cfg(status, cfg, wrapctx) ndis_status *status; ndis_handle *cfg; ndis_handle wrapctx; { *cfg = wrapctx; *status = NDIS_STATUS_SUCCESS; return; } __stdcall static void ndis_open_cfgbyname(status, cfg, subkey, subhandle) ndis_status *status; ndis_handle cfg; ndis_unicode_string *subkey; ndis_handle *subhandle; { *subhandle = cfg; *status = NDIS_STATUS_SUCCESS; return; } __stdcall static void ndis_open_cfgbyidx(status, cfg, idx, subkey, subhandle) ndis_status *status; ndis_handle cfg; uint32_t idx; ndis_unicode_string *subkey; ndis_handle *subhandle; { *status = NDIS_STATUS_FAILURE; return; } static ndis_status ndis_encode_parm(block, oid, type, parm) ndis_miniport_block *block; struct sysctl_oid *oid; ndis_parm_type type; ndis_config_parm **parm; { uint16_t *unicode; ndis_unicode_string *ustr; unicode = (uint16_t *)&block->nmb_dummybuf; switch(type) { case ndis_parm_string: ndis_ascii_to_unicode((char *)oid->oid_arg1, &unicode); (*parm)->ncp_type = ndis_parm_string; ustr = &(*parm)->ncp_parmdata.ncp_stringdata; ustr->nus_len = strlen((char *)oid->oid_arg1) * 2; ustr->nus_buf = unicode; break; case ndis_parm_int: (*parm)->ncp_type = ndis_parm_int; (*parm)->ncp_parmdata.ncp_intdata = strtol((char *)oid->oid_arg1, NULL, 10); break; case ndis_parm_hexint: (*parm)->ncp_type = ndis_parm_hexint; (*parm)->ncp_parmdata.ncp_intdata = strtoul((char *)oid->oid_arg1, NULL, 16); break; default: return(NDIS_STATUS_FAILURE); break; } return(NDIS_STATUS_SUCCESS); } __stdcall static void ndis_read_cfg(status, parm, cfg, key, type) ndis_status *status; ndis_config_parm **parm; ndis_handle cfg; ndis_unicode_string *key; ndis_parm_type type; { char *keystr = NULL; uint16_t *unicode; ndis_miniport_block *block; struct ndis_softc *sc; struct sysctl_oid *oidp; struct sysctl_ctx_entry *e; block = (ndis_miniport_block *)cfg; sc = (struct ndis_softc *)block->nmb_ifp; if (key->nus_len == 0 || key->nus_buf == NULL) { *status = NDIS_STATUS_FAILURE; return; } ndis_unicode_to_ascii(key->nus_buf, key->nus_len, &keystr); *parm = &block->nmb_replyparm; bzero((char *)&block->nmb_replyparm, sizeof(ndis_config_parm)); unicode = (uint16_t *)&block->nmb_dummybuf; /* * See if registry key is already in a list of known keys * included with the driver. */ TAILQ_FOREACH(e, &sc->ndis_ctx, link) { oidp = e->entry; if (strcmp(oidp->oid_name, keystr) == 0) { if (strcmp((char *)oidp->oid_arg1, "UNSET") == 0) { free(keystr, M_DEVBUF); *status = NDIS_STATUS_FAILURE; return; } *status = ndis_encode_parm(block, oidp, type, parm); free(keystr, M_DEVBUF); return; } } /* * If the key didn't match, add it to the list of dynamically * created ones. Sometimes, drivers refer to registry keys * that aren't documented in their .INF files. These keys * are supposed to be created by some sort of utility or * control panel snap-in that comes with the driver software. * Sometimes it's useful to be able to manipulate these. * If the driver requests the key in the form of a string, * make its default value an empty string, otherwise default * it to "0". */ if (type == ndis_parm_int || type == ndis_parm_hexint) ndis_add_sysctl(sc, keystr, "(dynamic integer key)", "UNSET", CTLFLAG_RW); else ndis_add_sysctl(sc, keystr, "(dynamic string key)", "UNSET", CTLFLAG_RW); free(keystr, M_DEVBUF); *status = NDIS_STATUS_FAILURE; return; } static ndis_status ndis_decode_parm(block, parm, val) ndis_miniport_block *block; ndis_config_parm *parm; char *val; { ndis_unicode_string *ustr; char *astr = NULL; switch(parm->ncp_type) { case ndis_parm_string: ustr = &parm->ncp_parmdata.ncp_stringdata; ndis_unicode_to_ascii(ustr->nus_buf, ustr->nus_len, &astr); bcopy(astr, val, 254); free(astr, M_DEVBUF); break; case ndis_parm_int: sprintf(val, "%d", parm->ncp_parmdata.ncp_intdata); break; case ndis_parm_hexint: sprintf(val, "%xu", parm->ncp_parmdata.ncp_intdata); break; default: return(NDIS_STATUS_FAILURE); break; } return(NDIS_STATUS_SUCCESS); } __stdcall static void ndis_write_cfg(status, cfg, key, parm) ndis_status *status; ndis_handle cfg; ndis_unicode_string *key; ndis_config_parm *parm; { char *keystr = NULL; ndis_miniport_block *block; struct ndis_softc *sc; struct sysctl_oid *oidp; struct sysctl_ctx_entry *e; char val[256]; block = (ndis_miniport_block *)cfg; sc = (struct ndis_softc *)block->nmb_ifp; ndis_unicode_to_ascii(key->nus_buf, key->nus_len, &keystr); /* Decode the parameter into a string. */ bzero(val, sizeof(val)); *status = ndis_decode_parm(block, parm, val); if (*status != NDIS_STATUS_SUCCESS) { free(keystr, M_DEVBUF); return; } /* See if the key already exists. */ TAILQ_FOREACH(e, &sc->ndis_ctx, link) { oidp = e->entry; if (strcmp(oidp->oid_name, keystr) == 0) { /* Found it, set the value. */ strcpy((char *)oidp->oid_arg1, val); free(keystr, M_DEVBUF); return; } } /* Not found, add a new key with the specified value. */ ndis_add_sysctl(sc, keystr, "(dynamically set key)", val, CTLFLAG_RW); free(keystr, M_DEVBUF); *status = NDIS_STATUS_SUCCESS; return; } __stdcall static void ndis_close_cfg(cfg) ndis_handle cfg; { return; } __stdcall static void ndis_create_lock(lock) ndis_spin_lock *lock; { lock->nsl_spinlock = (ndis_kspin_lock)mtx_pool_alloc(ndis_mtxpool); return; } __stdcall static void ndis_destroy_lock(lock) ndis_spin_lock *lock; { /* We use a mutex pool, so this is a no-op. */ return; } __stdcall static void ndis_lock(lock) ndis_spin_lock *lock; { mtx_pool_lock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock); return; } __stdcall static void ndis_unlock(lock) ndis_spin_lock *lock; { mtx_pool_unlock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock); return; } __stdcall static uint32_t ndis_read_pci(adapter, slot, offset, buf, len) ndis_handle adapter; uint32_t slot; uint32_t offset; void *buf; uint32_t len; { ndis_miniport_block *block; int i; char *dest; block = (ndis_miniport_block *)adapter; dest = buf; if (block == NULL || block->nmb_dev == NULL) return(0); for (i = 0; i < len; i++) dest[i] = pci_read_config(block->nmb_dev, i + offset, 1); return(len); } __stdcall static uint32_t ndis_write_pci(adapter, slot, offset, buf, len) ndis_handle adapter; uint32_t slot; uint32_t offset; void *buf; uint32_t len; { ndis_miniport_block *block; int i; char *dest; block = (ndis_miniport_block *)adapter; dest = buf; if (block == NULL || block->nmb_dev == NULL) return(0); for (i = 0; i < len; i++) pci_write_config(block->nmb_dev, i + offset, dest[i], 1); return(len); } /* * The errorlog routine uses a variable argument list, so we * have to declare it this way. */ #define ERRMSGLEN 512 static void ndis_syslog(ndis_handle adapter, ndis_error_code code, uint32_t numerrors, ...) { ndis_miniport_block *block; va_list ap; int i, error; char *str = NULL, *ustr = NULL; uint16_t flags; char msgbuf[ERRMSGLEN]; block = (ndis_miniport_block *)adapter; error = pe_get_message(block->nmb_img, code, &str, &i, &flags); if (error == 0 && flags & MESSAGE_RESOURCE_UNICODE) { ustr = msgbuf; ndis_unicode_to_ascii((uint16_t *)str, ((i / 2)) > (ERRMSGLEN - 1) ? ERRMSGLEN : i, &ustr); str = ustr; } device_printf (block->nmb_dev, "NDIS ERROR: %x (%s)\n", code, str == NULL ? "unknown error" : str); device_printf (block->nmb_dev, "NDIS NUMERRORS: %x\n", numerrors); va_start(ap, numerrors); for (i = 0; i < numerrors; i++) device_printf (block->nmb_dev, "argptr: %p\n", va_arg(ap, void *)); va_end(ap); return; } static void ndis_map_cb(arg, segs, nseg, error) void *arg; bus_dma_segment_t *segs; int nseg; int error; { struct ndis_map_arg *ctx; int i; if (error) return; ctx = arg; for (i = 0; i < nseg; i++) { ctx->nma_fraglist[i].npu_physaddr.np_quad = segs[i].ds_addr; ctx->nma_fraglist[i].npu_len = segs[i].ds_len; } ctx->nma_cnt = nseg; return; } __stdcall static void ndis_vtophys_load(adapter, buf, mapreg, writedev, addrarray, arraysize) ndis_handle adapter; ndis_buffer *buf; uint32_t mapreg; uint8_t writedev; ndis_paddr_unit *addrarray; uint32_t *arraysize; { ndis_miniport_block *block; struct ndis_softc *sc; struct ndis_map_arg nma; bus_dmamap_t map; int error; if (adapter == NULL) return; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)(block->nmb_ifp); if (mapreg > sc->ndis_mmapcnt) return; map = sc->ndis_mmaps[mapreg]; nma.nma_fraglist = addrarray; error = bus_dmamap_load(sc->ndis_mtag, map, MDL_VA(buf), buf->nb_bytecount, ndis_map_cb, (void *)&nma, BUS_DMA_NOWAIT); if (error) return; bus_dmamap_sync(sc->ndis_mtag, map, writedev ? BUS_DMASYNC_PREWRITE : BUS_DMASYNC_PREREAD); *arraysize = nma.nma_cnt; return; } __stdcall static void ndis_vtophys_unload(adapter, buf, mapreg) ndis_handle adapter; ndis_buffer *buf; uint32_t mapreg; { ndis_miniport_block *block; struct ndis_softc *sc; bus_dmamap_t map; if (adapter == NULL) return; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)(block->nmb_ifp); if (mapreg > sc->ndis_mmapcnt) return; map = sc->ndis_mmaps[mapreg]; bus_dmamap_sync(sc->ndis_mtag, map, BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); bus_dmamap_unload(sc->ndis_mtag, map); return; } /* * This is an older pre-miniport timer init routine which doesn't * accept a miniport context handle. The function context (ctx) * is supposed to be a pointer to the adapter handle, which should * have been handed to us via NdisSetAttributesEx(). We use this * function context to track down the corresponding ndis_miniport_block * structure. It's vital that we track down the miniport block structure, * so if we can't do it, we panic. Note that we also play some games * here by treating ndis_timer and ndis_miniport_timer as the same * thing. */ __stdcall static void ndis_init_timer(timer, func, ctx) ndis_timer *timer; ndis_timer_function func; void *ctx; { struct ndis_timer_entry *ne = NULL; ndis_miniport_block *block = NULL; TAILQ_FOREACH(block, &ndis_devhead, link) { if (block->nmb_miniportadapterctx == ctx) break; } if (block->nmb_miniportadapterctx != ctx) panic("NDIS driver timer context didn't " "match any adapter contexts"); ne = malloc(sizeof(struct ndis_timer_entry), M_DEVBUF, M_NOWAIT); callout_init(&ne->nte_ch, CALLOUT_MPSAFE); TAILQ_INSERT_TAIL(&block->nmb_timerlist, ne, link); ne->nte_timer = (ndis_miniport_timer *)timer; timer->nt_timer.nk_header.dh_sigstate = TRUE; timer->nt_dpc.nk_sysarg1 = &ne->nte_ch; timer->nt_dpc.nk_deferedfunc = (ndis_kdpc_func)func; timer->nt_dpc.nk_deferredctx = ctx; return; } __stdcall static void ndis_create_timer(timer, handle, func, ctx) ndis_miniport_timer *timer; ndis_handle *handle; ndis_timer_function func; void *ctx; { struct ndis_timer_entry *ne = NULL; ndis_miniport_block *block; block = (ndis_miniport_block *)handle; ne = malloc(sizeof(struct ndis_timer_entry), M_DEVBUF, M_NOWAIT); callout_init(&ne->nte_ch, CALLOUT_MPSAFE); TAILQ_INSERT_TAIL(&block->nmb_timerlist, ne, link); ne->nte_timer = timer; timer->nmt_ktimer.nk_header.dh_sigstate = TRUE; timer->nmt_dpc.nk_sysarg1 = &ne->nte_ch; timer->nmt_dpc.nk_deferedfunc = (ndis_kdpc_func)func; timer->nmt_dpc.nk_deferredctx = ctx; return; } /* * The driver's timer callout is __stdcall function, so we need this * intermediate step. */ static void ndis_timercall(arg) void *arg; { ndis_miniport_timer *timer; __stdcall ndis_timer_function timerfunc; timer = arg; timer->nmt_ktimer.nk_header.dh_sigstate = FALSE; timerfunc = (ndis_timer_function)timer->nmt_dpc.nk_deferedfunc; timerfunc(NULL, timer->nmt_dpc.nk_deferredctx, NULL, NULL); return; } /* * Windows specifies timeouts in milliseconds. We specify timeouts * in hz. Trying to compute a tenth of a second based on hz is tricky. * so we approximate. Note that we abuse the dpc portion of the * miniport timer structure to hold the UNIX callout handle. */ __stdcall static void ndis_set_timer(timer, msecs) ndis_miniport_timer *timer; uint32_t msecs; { struct callout *ch; struct timeval tv; tv.tv_sec = 0; tv.tv_usec = msecs * 1000; ch = timer->nmt_dpc.nk_sysarg1; timer->nmt_dpc.nk_sysarg2 = ndis_timercall; timer->nmt_ktimer.nk_header.dh_sigstate = TRUE; callout_reset(ch, tvtohz(&tv), timer->nmt_dpc.nk_sysarg2, timer); return; } static void ndis_tick(arg) void *arg; { ndis_miniport_timer *timer; struct callout *ch; __stdcall ndis_timer_function timerfunc; struct timeval tv; timer = arg; timer->nmt_ktimer.nk_header.dh_sigstate = FALSE; timerfunc = (ndis_timer_function)timer->nmt_dpc.nk_deferedfunc; timerfunc(NULL, timer->nmt_dpc.nk_deferredctx, NULL, NULL); /* Automatically reload timer. */ tv.tv_sec = 0; tv.tv_usec = timer->nmt_ktimer.nk_period * 1000; ch = timer->nmt_dpc.nk_sysarg1; timer->nmt_ktimer.nk_header.dh_sigstate = TRUE; timer->nmt_dpc.nk_sysarg2 = ndis_tick; callout_reset(ch, tvtohz(&tv), timer->nmt_dpc.nk_sysarg2, timer); return; } __stdcall static void ndis_set_periodic_timer(timer, msecs) ndis_miniport_timer *timer; uint32_t msecs; { struct callout *ch; struct timeval tv; tv.tv_sec = 0; tv.tv_usec = msecs * 1000; timer->nmt_ktimer.nk_period = msecs; ch = timer->nmt_dpc.nk_sysarg1; timer->nmt_dpc.nk_sysarg2 = ndis_tick; timer->nmt_ktimer.nk_header.dh_sigstate = TRUE; callout_reset(ch, tvtohz(&tv), timer->nmt_dpc.nk_sysarg2, timer); return; } __stdcall static void ndis_cancel_timer(timer, cancelled) ndis_miniport_timer *timer; uint8_t *cancelled; { struct callout *ch; if (timer == NULL) return; ch = timer->nmt_dpc.nk_sysarg1; if (ch == NULL) return; callout_stop(ch); *cancelled = timer->nmt_ktimer.nk_header.dh_sigstate; return; } __stdcall static void ndis_query_resources(status, adapter, list, buflen) ndis_status *status; ndis_handle adapter; ndis_resource_list *list; uint32_t *buflen; { ndis_miniport_block *block; struct ndis_softc *sc; int rsclen; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)block->nmb_ifp; rsclen = sizeof(ndis_resource_list) + (sizeof(cm_partial_resource_desc) * (sc->ndis_rescnt - 1)); if (*buflen < rsclen) { *buflen = rsclen; *status = NDIS_STATUS_INVALID_LENGTH; return; } bcopy((char *)block->nmb_rlist, (char *)list, *buflen); *status = NDIS_STATUS_SUCCESS; return; } __stdcall static ndis_status ndis_register_ioport(offset, adapter, port, numports) void **offset; ndis_handle adapter; uint32_t port; uint32_t numports; { struct ndis_miniport_block *block; struct ndis_softc *sc; if (adapter == NULL) return(NDIS_STATUS_FAILURE); block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)(block->nmb_ifp); if (sc->ndis_res_io == NULL) return(NDIS_STATUS_FAILURE); /* Don't let the device map more ports than we have. */ if (rman_get_size(sc->ndis_res_io) < numports) return(NDIS_STATUS_INVALID_LENGTH); *offset = (void *)rman_get_start(sc->ndis_res_io); return(NDIS_STATUS_SUCCESS); } __stdcall static void ndis_deregister_ioport(adapter, port, numports, offset) ndis_handle adapter; uint32_t port; uint32_t numports; void *offset; { return; } __stdcall static void ndis_read_netaddr(status, addr, addrlen, adapter) ndis_status *status; void **addr; uint32_t *addrlen; ndis_handle adapter; { struct ndis_softc *sc; ndis_miniport_block *block; uint8_t empty[] = { 0, 0, 0, 0, 0, 0 }; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)block->nmb_ifp; if (bcmp(sc->arpcom.ac_enaddr, empty, ETHER_ADDR_LEN) == 0) *status = NDIS_STATUS_FAILURE; else { *addr = sc->arpcom.ac_enaddr; *addrlen = ETHER_ADDR_LEN; *status = NDIS_STATUS_SUCCESS; } return; } __stdcall static ndis_status ndis_mapreg_cnt(bustype, cnt) uint32_t bustype; uint32_t *cnt; { *cnt = 8192; return(NDIS_STATUS_SUCCESS); } __stdcall static ndis_status ndis_alloc_mapreg(adapter, dmachannel, dmasize, physmapneeded, maxmap) ndis_handle adapter; uint32_t dmachannel; uint8_t dmasize; uint32_t physmapneeded; uint32_t maxmap; { struct ndis_softc *sc; ndis_miniport_block *block; int error, i, nseg = NDIS_MAXSEG; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)block->nmb_ifp; sc->ndis_mmaps = malloc(sizeof(bus_dmamap_t) * physmapneeded, M_DEVBUF, M_NOWAIT|M_ZERO); if (sc->ndis_mmaps == NULL) return(NDIS_STATUS_RESOURCES); error = bus_dma_tag_create(sc->ndis_parent_tag, ETHER_ALIGN, 0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, maxmap * nseg, nseg, maxmap, BUS_DMA_ALLOCNOW, NULL, NULL, &sc->ndis_mtag); if (error) { free(sc->ndis_mmaps, M_DEVBUF); return(NDIS_STATUS_RESOURCES); } for (i = 0; i < physmapneeded; i++) bus_dmamap_create(sc->ndis_mtag, 0, &sc->ndis_mmaps[i]); sc->ndis_mmapcnt = physmapneeded; return(NDIS_STATUS_SUCCESS); } __stdcall static void ndis_free_mapreg(adapter) ndis_handle adapter; { struct ndis_softc *sc; ndis_miniport_block *block; int i; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)block->nmb_ifp; for (i = 0; i < sc->ndis_mmapcnt; i++) bus_dmamap_destroy(sc->ndis_mtag, sc->ndis_mmaps[i]); free(sc->ndis_mmaps, M_DEVBUF); bus_dma_tag_destroy(sc->ndis_mtag); return; } static void ndis_mapshared_cb(arg, segs, nseg, error) void *arg; bus_dma_segment_t *segs; int nseg; int error; { ndis_physaddr *p; if (error || nseg > 1) return; p = arg; p->np_quad = segs[0].ds_addr; return; } /* * This maps to bus_dmamem_alloc(). */ __stdcall static void ndis_alloc_sharedmem(adapter, len, cached, vaddr, paddr) ndis_handle adapter; uint32_t len; uint8_t cached; void **vaddr; ndis_physaddr *paddr; { ndis_miniport_block *block; struct ndis_softc *sc; struct ndis_shmem *sh; int error; if (adapter == NULL) return; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)(block->nmb_ifp); sh = malloc(sizeof(struct ndis_shmem), M_DEVBUF, M_NOWAIT|M_ZERO); if (sh == NULL) return; error = bus_dma_tag_create(sc->ndis_parent_tag, 64, 0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, len, 1, len, BUS_DMA_ALLOCNOW, NULL, NULL, &sh->ndis_stag); if (error) { free(sh, M_DEVBUF); return; } error = bus_dmamem_alloc(sh->ndis_stag, vaddr, BUS_DMA_NOWAIT | BUS_DMA_ZERO, &sh->ndis_smap); if (error) { bus_dma_tag_destroy(sh->ndis_stag); free(sh, M_DEVBUF); return; } error = bus_dmamap_load(sh->ndis_stag, sh->ndis_smap, *vaddr, len, ndis_mapshared_cb, (void *)paddr, BUS_DMA_NOWAIT); if (error) { bus_dmamem_free(sh->ndis_stag, *vaddr, sh->ndis_smap); bus_dma_tag_destroy(sh->ndis_stag); free(sh, M_DEVBUF); return; } sh->ndis_saddr = *vaddr; sh->ndis_next = sc->ndis_shlist; sc->ndis_shlist = sh; return; } __stdcall static void ndis_alloc_sharedmem_async(adapter, len, cached, ctx) ndis_handle adapter; uint32_t len; uint8_t cached; void *ctx; { ndis_miniport_block *block; struct ndis_softc *sc; void *vaddr; ndis_physaddr paddr; __stdcall ndis_allocdone_handler donefunc; if (adapter == NULL) return; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)(block->nmb_ifp); donefunc = sc->ndis_chars.nmc_allocate_complete_func; ndis_alloc_sharedmem(adapter, len, cached, &vaddr, &paddr); donefunc(adapter, vaddr, &paddr, len, ctx); return; } __stdcall static void ndis_free_sharedmem(adapter, len, cached, vaddr, paddr) ndis_handle adapter; uint32_t len; uint8_t cached; void *vaddr; ndis_physaddr paddr; { ndis_miniport_block *block; struct ndis_softc *sc; struct ndis_shmem *sh, *prev; if (vaddr == NULL || adapter == NULL) return; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)(block->nmb_ifp); sh = prev = sc->ndis_shlist; while (sh) { if (sh->ndis_saddr == vaddr) break; prev = sh; sh = sh->ndis_next; } bus_dmamap_unload(sh->ndis_stag, sh->ndis_smap); bus_dmamem_free(sh->ndis_stag, vaddr, sh->ndis_smap); bus_dma_tag_destroy(sh->ndis_stag); if (sh == sc->ndis_shlist) sc->ndis_shlist = sh->ndis_next; else prev->ndis_next = sh->ndis_next; free(sh, M_DEVBUF); return; } __stdcall static ndis_status ndis_map_iospace(vaddr, adapter, paddr, len) void **vaddr; ndis_handle adapter; ndis_physaddr paddr; uint32_t len; { ndis_miniport_block *block; struct ndis_softc *sc; if (adapter == NULL) return(NDIS_STATUS_FAILURE); block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)(block->nmb_ifp); if (sc->ndis_res_mem == NULL) return(NDIS_STATUS_FAILURE); *vaddr = (void *)rman_get_virtual(sc->ndis_res_mem); return(NDIS_STATUS_SUCCESS); } __stdcall static void ndis_unmap_iospace(adapter, vaddr, len) ndis_handle adapter; void *vaddr; uint32_t len; { return; } __stdcall static uint32_t ndis_cachefill(void) { return(128); } __stdcall static uint32_t ndis_dma_align(handle) ndis_handle handle; { return(128); } /* * NDIS has two methods for dealing with NICs that support DMA. * One is to just pass packets to the driver and let it call * NdisMStartBufferPhysicalMapping() to map each buffer in the packet * all by itself, and the other is to let the NDIS library handle the * buffer mapping internally, and hand the driver an already populated * scatter/gather fragment list. If the driver calls * NdisMInitializeScatterGatherDma(), it wants to use the latter * method. */ __stdcall static ndis_status ndis_init_sc_dma(adapter, is64, maxphysmap) ndis_handle adapter; uint8_t is64; uint32_t maxphysmap; { struct ndis_softc *sc; ndis_miniport_block *block; int error; if (adapter == NULL) return(NDIS_STATUS_FAILURE); block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)block->nmb_ifp; /* Don't do this twice. */ if (sc->ndis_sc == 1) return(NDIS_STATUS_SUCCESS); error = bus_dma_tag_create(sc->ndis_parent_tag, ETHER_ALIGN, 0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES * NDIS_MAXSEG, NDIS_MAXSEG, MCLBYTES, BUS_DMA_ALLOCNOW, NULL, NULL, &sc->ndis_ttag); sc->ndis_sc = 1; return(NDIS_STATUS_SUCCESS); } __stdcall static void ndis_alloc_packetpool(status, pool, descnum, protrsvdlen) ndis_status *status; ndis_handle *pool; uint32_t descnum; uint32_t protrsvdlen; { ndis_packet *cur; int i; *pool = malloc(sizeof(ndis_packet) * ((descnum + NDIS_POOL_EXTRA) + 1), M_DEVBUF, M_NOWAIT|M_ZERO); if (pool == NULL) { *status = NDIS_STATUS_RESOURCES; return; } cur = (ndis_packet *)*pool; cur->np_private.npp_flags = 0x1; /* mark the head of the list */ for (i = 0; i < (descnum + NDIS_POOL_EXTRA); i++) { cur->np_private.npp_head = (ndis_handle)(cur + 1); cur++; } *status = NDIS_STATUS_SUCCESS; return; } __stdcall static void ndis_ex_alloc_packetpool(status, pool, descnum, oflowdescnum, protrsvdlen) ndis_status *status; ndis_handle *pool; uint32_t descnum; uint32_t oflowdescnum; uint32_t protrsvdlen; { return(ndis_alloc_packetpool(status, pool, descnum + oflowdescnum, protrsvdlen)); } __stdcall static uint32_t ndis_packetpool_use(pool) ndis_handle pool; { ndis_packet *head; head = (ndis_packet *)pool; return(head->np_private.npp_count); } __stdcall static void ndis_free_packetpool(pool) ndis_handle pool; { free(pool, M_DEVBUF); return; } __stdcall static void ndis_alloc_packet(status, packet, pool) ndis_status *status; ndis_packet **packet; ndis_handle pool; { ndis_packet *head, *pkt; head = (ndis_packet *)pool; if (head->np_private.npp_flags != 0x1) { *status = NDIS_STATUS_FAILURE; return; } pkt = (ndis_packet *)head->np_private.npp_head; if (pkt == NULL) { *status = NDIS_STATUS_RESOURCES; return; } head->np_private.npp_head = pkt->np_private.npp_head; pkt->np_private.npp_head = pkt->np_private.npp_tail = NULL; /* Save pointer to the pool. */ pkt->np_private.npp_pool = head; /* Set the oob offset pointer. Lots of things expect this. */ pkt->np_private.npp_packetooboffset = offsetof(ndis_packet, np_oob); /* * We must initialize the packet flags correctly in order * for the NDIS_SET_PACKET_MEDIA_SPECIFIC_INFO() and * NDIS_GET_PACKET_MEDIA_SPECIFIC_INFO() to work correctly. */ pkt->np_private.npp_ndispktflags = NDIS_PACKET_ALLOCATED_BY_NDIS; *packet = pkt; head->np_private.npp_count++; *status = NDIS_STATUS_SUCCESS; return; } __stdcall static void ndis_release_packet(packet) ndis_packet *packet; { ndis_packet *head; if (packet == NULL || packet->np_private.npp_pool == NULL) return; head = packet->np_private.npp_pool; if (head->np_private.npp_flags != 0x1) return; packet->np_private.npp_head = head->np_private.npp_head; head->np_private.npp_head = (ndis_buffer *)packet; head->np_private.npp_count--; return; } __stdcall static void ndis_unchain_headbuf(packet, buf) ndis_packet *packet; ndis_buffer **buf; { ndis_packet_private *priv; if (packet == NULL || buf == NULL) return; priv = &packet->np_private; priv->npp_validcounts = FALSE; if (priv->npp_head == priv->npp_tail) { *buf = priv->npp_head; priv->npp_head = priv->npp_tail = NULL; } else { *buf = priv->npp_head; priv->npp_head = (*buf)->nb_next; } return; } __stdcall static void ndis_unchain_tailbuf(packet, buf) ndis_packet *packet; ndis_buffer **buf; { ndis_packet_private *priv; ndis_buffer *tmp; if (packet == NULL || buf == NULL) return; priv = &packet->np_private; priv->npp_validcounts = FALSE; if (priv->npp_head == priv->npp_tail) { *buf = priv->npp_head; priv->npp_head = priv->npp_tail = NULL; } else { *buf = priv->npp_tail; tmp = priv->npp_head; while (tmp->nb_next != priv->npp_tail) tmp = tmp->nb_next; priv->npp_tail = tmp; tmp->nb_next = NULL; } return; } /* * The NDIS "buffer" manipulation functions are somewhat misnamed. * They don't really allocate buffers: they allocate buffer mappings. * The idea is you reserve a chunk of DMA-able memory using * NdisMAllocateSharedMemory() and then use NdisAllocateBuffer() * to obtain the virtual address of the DMA-able region. * ndis_alloc_bufpool() is analagous to bus_dma_tag_create(). */ __stdcall static void ndis_alloc_bufpool(status, pool, descnum) ndis_status *status; ndis_handle *pool; uint32_t descnum; { ndis_buffer *cur; int i; *pool = malloc(sizeof(ndis_buffer) * ((descnum + NDIS_POOL_EXTRA) + 1), M_DEVBUF, M_NOWAIT|M_ZERO); if (pool == NULL) { *status = NDIS_STATUS_RESOURCES; return; } cur = (ndis_buffer *)*pool; cur->nb_flags = 0x1; /* mark the head of the list */ for (i = 0; i < (descnum + NDIS_POOL_EXTRA); i++) { cur->nb_next = cur + 1; cur++; } *status = NDIS_STATUS_SUCCESS; return; } __stdcall static void ndis_free_bufpool(pool) ndis_handle pool; { free(pool, M_DEVBUF); return; } /* * This maps to a bus_dmamap_create() and bus_dmamap_load(). */ __stdcall static void ndis_alloc_buf(status, buffer, pool, vaddr, len) ndis_status *status; ndis_buffer **buffer; ndis_handle pool; void *vaddr; uint32_t len; { ndis_buffer *head, *buf; head = (ndis_buffer *)pool; if (head->nb_flags != 0x1) { *status = NDIS_STATUS_FAILURE; return; } buf = head->nb_next; if (buf == NULL) { *status = NDIS_STATUS_RESOURCES; return; } head->nb_next = buf->nb_next; /* Save pointer to the pool. */ buf->nb_process = head; MDL_INIT(buf, vaddr, len); *buffer = buf; *status = NDIS_STATUS_SUCCESS; return; } __stdcall static void ndis_release_buf(buf) ndis_buffer *buf; { ndis_buffer *head; if (buf == NULL || buf->nb_process == NULL) return; head = buf->nb_process; if (head->nb_flags != 0x1) return; buf->nb_next = head->nb_next; head->nb_next = buf; return; } /* Aw c'mon. */ __stdcall static uint32_t ndis_buflen(buf) ndis_buffer *buf; { return(buf->nb_bytecount); } /* * Get the virtual address and length of a buffer. * Note: the vaddr argument is optional. */ __stdcall static void ndis_query_buf(buf, vaddr, len) ndis_buffer *buf; void **vaddr; uint32_t *len; { if (vaddr != NULL) *vaddr = MDL_VA(buf); *len = buf->nb_bytecount; return; } /* Same as above -- we don't care about the priority. */ __stdcall static void ndis_query_buf_safe(buf, vaddr, len, prio) ndis_buffer *buf; void **vaddr; uint32_t *len; uint32_t prio; { if (vaddr != NULL) *vaddr = MDL_VA(buf); *len = buf->nb_bytecount; return; } /* Damnit Microsoft!! How many ways can you do the same thing?! */ __stdcall static void * ndis_buf_vaddr(buf) ndis_buffer *buf; { return(MDL_VA(buf)); } __stdcall static void * ndis_buf_vaddr_safe(buf, prio) ndis_buffer *buf; uint32_t prio; { return(MDL_VA(buf)); } __stdcall static void ndis_adjust_buflen(buf, len) ndis_buffer *buf; int len; { buf->nb_bytecount = len; return; } __stdcall static uint32_t ndis_interlock_inc(addend) uint32_t *addend; { atomic_add_long((u_long *)addend, 1); return(*addend); } __stdcall static uint32_t ndis_interlock_dec(addend) uint32_t *addend; { atomic_subtract_long((u_long *)addend, 1); return(*addend); } __stdcall static void ndis_init_event(event) ndis_event *event; { event->ne_event.nk_header.dh_sigstate = FALSE; return; } __stdcall static void ndis_set_event(event) ndis_event *event; { event->ne_event.nk_header.dh_sigstate = TRUE; wakeup(event); return; } __stdcall static void ndis_reset_event(event) ndis_event *event; { event->ne_event.nk_header.dh_sigstate = FALSE; wakeup(event); return; } __stdcall static uint8_t ndis_wait_event(event, msecs) ndis_event *event; uint32_t msecs; { int error; struct timeval tv; if (event->ne_event.nk_header.dh_sigstate == TRUE) return(TRUE); tv.tv_sec = 0; tv.tv_usec = msecs * 1000; error = tsleep(event, PPAUSE|PCATCH, "ndis", tvtohz(&tv)); return(event->ne_event.nk_header.dh_sigstate); } __stdcall static ndis_status ndis_unicode2ansi(dstr, sstr) ndis_ansi_string *dstr; ndis_unicode_string *sstr; { if (dstr == NULL || sstr == NULL) return(NDIS_STATUS_FAILURE); if (ndis_unicode_to_ascii(sstr->nus_buf, sstr->nus_len, &dstr->nas_buf)) return(NDIS_STATUS_FAILURE); dstr->nas_len = dstr->nas_maxlen = strlen(dstr->nas_buf); return (NDIS_STATUS_SUCCESS); } __stdcall static ndis_status ndis_ansi2unicode(dstr, sstr) ndis_unicode_string *dstr; ndis_ansi_string *sstr; { char *str; if (dstr == NULL || sstr == NULL) return(NDIS_STATUS_FAILURE); str = malloc(sstr->nas_len + 1, M_DEVBUF, M_NOWAIT); if (str == NULL) return(NDIS_STATUS_FAILURE); strncpy(str, sstr->nas_buf, sstr->nas_len); *(str + sstr->nas_len) = '\0'; if (ndis_ascii_to_unicode(str, &dstr->nus_buf)) { free(str, M_DEVBUF); return(NDIS_STATUS_FAILURE); } dstr->nus_len = dstr->nus_maxlen = sstr->nas_len * 2; free(str, M_DEVBUF); return (NDIS_STATUS_SUCCESS); } __stdcall static ndis_status ndis_assign_pcirsrc(adapter, slot, list) ndis_handle adapter; uint32_t slot; ndis_resource_list **list; { ndis_miniport_block *block; if (adapter == NULL || list == NULL) return (NDIS_STATUS_FAILURE); block = (ndis_miniport_block *)adapter; *list = block->nmb_rlist; return (NDIS_STATUS_SUCCESS); } __stdcall static ndis_status ndis_register_intr(intr, adapter, ivec, ilevel, reqisr, shared, imode) ndis_miniport_interrupt *intr; ndis_handle adapter; uint32_t ivec; uint32_t ilevel; uint8_t reqisr; uint8_t shared; ndis_interrupt_mode imode; { ndis_miniport_block *block; block = adapter; intr->ni_block = adapter; intr->ni_isrreq = reqisr; intr->ni_shared = shared; block->nmb_interrupt = intr; return(NDIS_STATUS_SUCCESS); } __stdcall static void ndis_deregister_intr(intr) ndis_miniport_interrupt *intr; { return; } __stdcall static void ndis_register_shutdown(adapter, shutdownctx, shutdownfunc) ndis_handle adapter; void *shutdownctx; ndis_shutdown_handler shutdownfunc; { ndis_miniport_block *block; ndis_miniport_characteristics *chars; struct ndis_softc *sc; if (adapter == NULL) return; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)block->nmb_ifp; chars = &sc->ndis_chars; chars->nmc_shutdown_handler = shutdownfunc; chars->nmc_rsvd0 = shutdownctx; return; } __stdcall static void ndis_deregister_shutdown(adapter) ndis_handle adapter; { ndis_miniport_block *block; ndis_miniport_characteristics *chars; struct ndis_softc *sc; if (adapter == NULL) return; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)block->nmb_ifp; chars = &sc->ndis_chars; chars->nmc_shutdown_handler = NULL; chars->nmc_rsvd0 = NULL; return; } __stdcall static uint32_t ndis_numpages(buf) ndis_buffer *buf; { if (buf == NULL) return(0); if (buf->nb_bytecount == 0) return(1); return(SPAN_PAGES(MDL_VA(buf), buf->nb_bytecount)); } __stdcall static void ndis_buf_physpages(buf, pages) ndis_buffer *buf; uint32_t *pages; { if (buf == NULL) return; *pages = ndis_numpages(buf); return; } __stdcall static void ndis_query_bufoffset(buf, off, len) ndis_buffer *buf; uint32_t *off; uint32_t *len; { if (buf == NULL) return; *off = buf->nb_byteoffset; *len = buf->nb_bytecount; return; } __stdcall static void ndis_sleep(usecs) uint32_t usecs; { struct timeval tv; uint32_t dummy; tv.tv_sec = 0; tv.tv_usec = usecs; tsleep(&dummy, PPAUSE|PCATCH, "ndis", tvtohz(&tv)); return; } __stdcall static uint32_t ndis_read_pccard_amem(handle, offset, buf, len) ndis_handle handle; uint32_t offset; void *buf; uint32_t len; { struct ndis_softc *sc; ndis_miniport_block *block; bus_space_handle_t bh; bus_space_tag_t bt; char *dest; int i; if (handle == NULL) return(0); block = (ndis_miniport_block *)handle; sc = (struct ndis_softc *)block->nmb_ifp; dest = buf; bh = rman_get_bushandle(sc->ndis_res_am); bt = rman_get_bustag(sc->ndis_res_am); for (i = 0; i < len; i++) dest[i] = bus_space_read_1(bt, bh, (offset * 2) + (i * 2)); return(i); } __stdcall static uint32_t ndis_write_pccard_amem(handle, offset, buf, len) ndis_handle handle; uint32_t offset; void *buf; uint32_t len; { struct ndis_softc *sc; ndis_miniport_block *block; bus_space_handle_t bh; bus_space_tag_t bt; char *src; int i; if (handle == NULL) return(0); block = (ndis_miniport_block *)handle; sc = (struct ndis_softc *)block->nmb_ifp; src = buf; bh = rman_get_bushandle(sc->ndis_res_am); bt = rman_get_bustag(sc->ndis_res_am); for (i = 0; i < len; i++) bus_space_write_1(bt, bh, (offset * 2) + (i * 2), src[i]); return(i); } __stdcall static ndis_list_entry * ndis_insert_head(head, entry, lock) ndis_list_entry *head; ndis_list_entry *entry; ndis_spin_lock *lock; { ndis_list_entry *flink; mtx_pool_lock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock); flink = head->nle_flink; entry->nle_flink = flink; entry->nle_blink = head; flink->nle_blink = entry; head->nle_flink = entry; mtx_pool_unlock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock); return(flink); } __stdcall static ndis_list_entry * ndis_remove_head(head, lock) ndis_list_entry *head; ndis_spin_lock *lock; { ndis_list_entry *flink; ndis_list_entry *entry; mtx_pool_lock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock); entry = head->nle_flink; flink = entry->nle_flink; head->nle_flink = flink; flink->nle_blink = head; mtx_pool_unlock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock); return(entry); } __stdcall static ndis_list_entry * ndis_insert_tail(head, entry, lock) ndis_list_entry *head; ndis_list_entry *entry; ndis_spin_lock *lock; { ndis_list_entry *blink; mtx_pool_lock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock); blink = head->nle_blink; entry->nle_flink = head; entry->nle_blink = blink; blink->nle_flink = entry; head->nle_blink = entry; mtx_pool_unlock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock); return(blink); } __stdcall static uint8_t ndis_sync_with_intr(intr, syncfunc, syncctx) ndis_miniport_interrupt *intr; void *syncfunc; void *syncctx; { struct ndis_softc *sc; __stdcall uint8_t (*sync)(void *); uint8_t rval; if (syncfunc == NULL || syncctx == NULL) return(0); sc = (struct ndis_softc *)intr->ni_block->nmb_ifp; sync = syncfunc; mtx_pool_lock(ndis_mtxpool, sc->ndis_intrmtx); rval = sync(syncctx); mtx_pool_unlock(ndis_mtxpool, sc->ndis_intrmtx); return(rval); } /* * Return the number of 100 nanosecond intervals since * January 1, 1601. (?!?!) */ __stdcall static void ndis_time(tval) uint64_t *tval; { struct timespec ts; nanotime(&ts); *tval = (uint64_t)ts.tv_nsec / 100 + (uint64_t)ts.tv_sec * 10000000 + 11644473600; } /* * Return the number of milliseconds since the system booted. */ __stdcall static void ndis_uptime(tval) uint32_t *tval; { struct timespec ts; nanouptime(&ts); *tval = ts.tv_nsec / 1000000 + ts.tv_sec * 1000; } __stdcall static void ndis_init_string(dst, src) ndis_unicode_string *dst; char *src; { ndis_unicode_string *u; u = dst; u->nus_buf = NULL; if (ndis_ascii_to_unicode(src, &u->nus_buf)) return; u->nus_len = u->nus_maxlen = strlen(src) * 2; return; } __stdcall static void ndis_free_string(str) ndis_unicode_string *str; { if (str == NULL) return; if (str->nus_buf != NULL) free(str->nus_buf, M_DEVBUF); free(str, M_DEVBUF); return; } __stdcall static ndis_status ndis_remove_miniport(adapter) ndis_handle *adapter; { return(NDIS_STATUS_SUCCESS); } __stdcall static void ndis_init_ansi_string(dst, src) ndis_ansi_string *dst; char *src; { ndis_ansi_string *a; a = dst; if (a == NULL) return; if (src == NULL) { a->nas_len = a->nas_maxlen = 0; a->nas_buf = NULL; } else { a->nas_buf = src; a->nas_len = a->nas_maxlen = strlen(src); } return; } __stdcall static void ndis_init_unicode_string(dst, src) ndis_unicode_string *dst; uint16_t *src; { ndis_unicode_string *u; int i; u = dst; if (u == NULL) return; if (src == NULL) { u->nus_len = u->nus_maxlen = 0; u->nus_buf = NULL; } else { i = 0; while(src[i] != 0) i++; u->nus_buf = src; u->nus_len = u->nus_maxlen = i * 2; } return; } __stdcall static void ndis_get_devprop(adapter, phydevobj, funcdevobj, nextdevobj, resources, transresources) ndis_handle adapter; void *phydevobj; void *funcdevobj; void *nextdevobj; cm_resource_list *resources; cm_resource_list *transresources; { return; } __stdcall static void ndis_firstbuf(packet, buf, firstva, firstlen, totlen) ndis_packet *packet; ndis_buffer **buf; void **firstva; uint32_t *firstlen; uint32_t *totlen; { ndis_buffer *tmp; tmp = packet->np_private.npp_head; *buf = tmp; if (tmp == NULL) { *firstva = NULL; *firstlen = *totlen = 0; } else { *firstva = MDL_VA(tmp); *firstlen = *totlen = tmp->nb_bytecount; for (tmp = tmp->nb_next; tmp != NULL; tmp = tmp->nb_next) *totlen += tmp->nb_bytecount; } return; } __stdcall static void ndis_firstbuf_safe(packet, buf, firstva, firstlen, totlen, prio) ndis_packet *packet; ndis_buffer **buf; void **firstva; uint32_t *firstlen; uint32_t *totlen; uint32_t prio; { ndis_firstbuf(packet, buf, firstva, firstlen, totlen); } /* can also return NDIS_STATUS_RESOURCES/NDIS_STATUS_ERROR_READING_FILE */ __stdcall static void ndis_open_file(status, filehandle, filelength, filename, highestaddr) ndis_status *status; ndis_handle *filehandle; uint32_t *filelength; ndis_unicode_string *filename; ndis_physaddr highestaddr; { char *afilename = NULL; struct thread *td = curthread; struct nameidata nd; int flags, error; struct vattr vat; struct vattr *vap = &vat; ndis_fh *fh; char path[MAXPATHLEN]; ndis_unicode_to_ascii(filename->nus_buf, filename->nus_len, &afilename); sprintf(path, "%s/%s", ndis_filepath, afilename); free(afilename, M_DEVBUF); fh = malloc(sizeof(ndis_fh), M_TEMP, M_NOWAIT); if (fh == NULL) { *status = NDIS_STATUS_RESOURCES; return; } mtx_lock(&Giant); + + /* Some threads don't have a current working directory. */ + + if (td->td_proc->p_fd->fd_rdir == NULL) + td->td_proc->p_fd->fd_rdir = rootvnode; + if (td->td_proc->p_fd->fd_cdir == NULL) + td->td_proc->p_fd->fd_cdir = rootvnode; + NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, td); flags = FREAD; error = vn_open(&nd, &flags, 0, -1); if (error) { mtx_unlock(&Giant); *status = NDIS_STATUS_FILE_NOT_FOUND; free(fh, M_TEMP); + printf("ndis_open_file(): unable to open file '%s'\n", path); return; } NDFREE(&nd, NDF_ONLY_PNBUF); /* Get the file size. */ VOP_GETATTR(nd.ni_vp, vap, NOCRED, td); VOP_UNLOCK(nd.ni_vp, 0, td); mtx_unlock(&Giant); fh->nf_vp = nd.ni_vp; fh->nf_map = NULL; *filehandle = fh; *filelength = fh->nf_maplen = vap->va_size & 0xFFFFFFFF; *status = NDIS_STATUS_SUCCESS; return; } __stdcall static void ndis_map_file(status, mappedbuffer, filehandle) ndis_status *status; void **mappedbuffer; ndis_handle filehandle; { ndis_fh *fh; struct thread *td = curthread; int error, resid; if (filehandle == NULL) { *status = NDIS_STATUS_FAILURE; return; } fh = (ndis_fh *)filehandle; if (fh->nf_vp == NULL) { *status = NDIS_STATUS_FAILURE; return; } if (fh->nf_map != NULL) { *status = NDIS_STATUS_ALREADY_MAPPED; return; } fh->nf_map = malloc(fh->nf_maplen, M_DEVBUF, M_NOWAIT); if (fh->nf_map == NULL) { *status = NDIS_STATUS_RESOURCES; return; } mtx_lock(&Giant); error = vn_rdwr(UIO_READ, fh->nf_vp, fh->nf_map, fh->nf_maplen, 0, UIO_SYSSPACE, 0, td->td_ucred, NOCRED, &resid, td); mtx_unlock(&Giant); if (error) *status = NDIS_STATUS_FAILURE; else { *status = NDIS_STATUS_SUCCESS; *mappedbuffer = fh->nf_map; } return; } __stdcall static void ndis_unmap_file(filehandle) ndis_handle filehandle; { ndis_fh *fh; fh = (ndis_fh *)filehandle; if (fh->nf_map == NULL) return; free(fh->nf_map, M_DEVBUF); fh->nf_map = NULL; return; } __stdcall static void ndis_close_file(filehandle) ndis_handle filehandle; { struct thread *td = curthread; ndis_fh *fh; if (filehandle == NULL) return; fh = (ndis_fh *)filehandle; if (fh->nf_map != NULL) { free(fh->nf_map, M_DEVBUF); fh->nf_map = NULL; } if (fh->nf_vp == NULL) return; mtx_lock(&Giant); vn_close(fh->nf_vp, FREAD, td->td_ucred, td); mtx_unlock(&Giant); fh->nf_vp = NULL; free(fh, M_DEVBUF); return; } __stdcall static uint8_t ndis_cpu_cnt() { return(mp_ncpus); } typedef void (*ndis_statusdone_handler)(ndis_handle); typedef void (*ndis_status_handler)(ndis_handle, ndis_status, void *, uint32_t); __stdcall static void ndis_ind_statusdone(adapter) ndis_handle adapter; { ndis_miniport_block *block; __stdcall ndis_statusdone_handler statusdonefunc; block = (ndis_miniport_block *)adapter; statusdonefunc = block->nmb_statusdone_func; statusdonefunc(adapter); return; } __stdcall static void ndis_ind_status(adapter, status, sbuf, slen) ndis_handle adapter; ndis_status status; void *sbuf; uint32_t slen; { ndis_miniport_block *block; __stdcall ndis_status_handler statusfunc; block = (ndis_miniport_block *)adapter; statusfunc = block->nmb_status_func; statusfunc(adapter, status, sbuf, slen); return; } static void ndis_workfunc(ctx) void *ctx; { ndis_work_item *work; __stdcall ndis_proc workfunc; work = ctx; workfunc = work->nwi_func; workfunc(work, work->nwi_ctx); return; } __stdcall static ndis_status ndis_sched_workitem(work) ndis_work_item *work; { ndis_sched(ndis_workfunc, work, NDIS_TASKQUEUE); return(NDIS_STATUS_SUCCESS); } __stdcall static void ndis_pkt_to_pkt(dpkt, doff, reqlen, spkt, soff, cpylen) ndis_packet *dpkt; uint32_t doff; uint32_t reqlen; ndis_packet *spkt; uint32_t soff; uint32_t *cpylen; { ndis_buffer *src, *dst; char *sptr, *dptr; int resid, copied, len, scnt, dcnt; *cpylen = 0; src = spkt->np_private.npp_head; dst = dpkt->np_private.npp_head; sptr = MDL_VA(src); dptr = MDL_VA(dst); scnt = src->nb_bytecount; dcnt = dst->nb_bytecount; while (soff) { if (src->nb_bytecount > soff) { sptr += soff; scnt = src->nb_bytecount - soff; break; } soff -= src->nb_bytecount; src = src->nb_next; if (src == NULL) return; sptr = MDL_VA(src); } while (doff) { if (dst->nb_bytecount > doff) { dptr += doff; dcnt = dst->nb_bytecount - doff; break; } doff -= dst->nb_bytecount; dst = dst->nb_next; if (dst == NULL) return; dptr = MDL_VA(dst); } resid = reqlen; copied = 0; while(1) { if (resid < scnt) len = resid; else len = scnt; if (dcnt < len) len = dcnt; bcopy(sptr, dptr, len); copied += len; resid -= len; if (resid == 0) break; dcnt -= len; if (dcnt == 0) { dst = dst->nb_next; if (dst == NULL) break; dptr = MDL_VA(dst); dcnt = dst->nb_bytecount; } scnt -= len; if (scnt == 0) { src = src->nb_next; if (src == NULL) break; sptr = MDL_VA(src); scnt = src->nb_bytecount; } } *cpylen = copied; return; } __stdcall static void ndis_pkt_to_pkt_safe(dpkt, doff, reqlen, spkt, soff, cpylen, prio) ndis_packet *dpkt; uint32_t doff; uint32_t reqlen; ndis_packet *spkt; uint32_t soff; uint32_t *cpylen; uint32_t prio; { ndis_pkt_to_pkt(dpkt, doff, reqlen, spkt, soff, cpylen); return; } __stdcall static ndis_status ndis_register_dev(handle, devname, symname, majorfuncs, devobj, devhandle) ndis_handle *handle; ndis_unicode_string *devname; ndis_unicode_string *symname; void *majorfuncs; void *devobj; ndis_handle **devhandle; { return(NDIS_STATUS_SUCCESS); } __stdcall static ndis_status ndis_deregister_dev(devhandle) ndis_handle *devhandle; { return(NDIS_STATUS_SUCCESS); } __stdcall static void dummy() { printf ("NDIS dummy called...\n"); return; } image_patch_table ndis_functbl[] = { { "NdisCopyFromPacketToPacket", (FUNC)ndis_pkt_to_pkt }, { "NdisCopyFromPacketToPacketSafe", (FUNC)ndis_pkt_to_pkt_safe }, { "NdisScheduleWorkItem", (FUNC)ndis_sched_workitem }, { "NdisMIndicateStatusComplete", (FUNC)ndis_ind_statusdone }, { "NdisMIndicateStatus", (FUNC)ndis_ind_status }, { "NdisSystemProcessorCount", (FUNC)ndis_cpu_cnt }, { "NdisUnchainBufferAtBack", (FUNC)ndis_unchain_tailbuf, }, { "NdisGetFirstBufferFromPacket", (FUNC)ndis_firstbuf }, { "NdisGetFirstBufferFromPacketSafe", (FUNC)ndis_firstbuf_safe }, { "NdisGetBufferPhysicalArraySize", (FUNC)ndis_buf_physpages }, { "NdisMGetDeviceProperty", (FUNC)ndis_get_devprop }, { "NdisInitAnsiString", (FUNC)ndis_init_ansi_string }, { "NdisInitUnicodeString", (FUNC)ndis_init_unicode_string }, { "NdisWriteConfiguration", (FUNC)ndis_write_cfg }, { "NdisAnsiStringToUnicodeString", (FUNC)ndis_ansi2unicode }, { "NdisTerminateWrapper", (FUNC)ndis_termwrap }, { "NdisOpenConfigurationKeyByName", (FUNC)ndis_open_cfgbyname }, { "NdisOpenConfigurationKeyByIndex", (FUNC)ndis_open_cfgbyidx }, { "NdisMRemoveMiniport", (FUNC)ndis_remove_miniport }, { "NdisInitializeString", (FUNC)ndis_init_string }, { "NdisFreeString", (FUNC)ndis_free_string }, { "NdisGetCurrentSystemTime", (FUNC)ndis_time }, { "NdisGetSystemUpTime", (FUNC)ndis_uptime }, { "NdisMSynchronizeWithInterrupt", (FUNC)ndis_sync_with_intr }, { "NdisMAllocateSharedMemoryAsync", (FUNC)ndis_alloc_sharedmem_async }, { "NdisInterlockedInsertHeadList", (FUNC)ndis_insert_head }, { "NdisInterlockedInsertTailList", (FUNC)ndis_insert_tail }, { "NdisInterlockedRemoveHeadList", (FUNC)ndis_remove_head }, { "NdisInitializeWrapper", (FUNC)ndis_initwrap }, { "NdisMRegisterMiniport", (FUNC)ndis_register_miniport }, { "NdisAllocateMemoryWithTag", (FUNC)ndis_malloc_withtag }, { "NdisAllocateMemory", (FUNC)ndis_malloc }, { "NdisMSetAttributesEx", (FUNC)ndis_setattr_ex }, { "NdisCloseConfiguration", (FUNC)ndis_close_cfg }, { "NdisReadConfiguration", (FUNC)ndis_read_cfg }, { "NdisOpenConfiguration", (FUNC)ndis_open_cfg }, { "NdisReleaseSpinLock", (FUNC)ndis_unlock }, { "NdisDprAcquireSpinLock", (FUNC)ndis_lock }, { "NdisDprReleaseSpinLock", (FUNC)ndis_unlock }, { "NdisAcquireSpinLock", (FUNC)ndis_lock }, { "NdisAllocateSpinLock", (FUNC)ndis_create_lock }, { "NdisFreeSpinLock", (FUNC)ndis_destroy_lock }, { "NdisFreeMemory", (FUNC)ndis_free }, { "NdisReadPciSlotInformation", (FUNC)ndis_read_pci }, { "NdisWritePciSlotInformation",(FUNC)ndis_write_pci }, { "NdisImmediateReadPciSlotInformation", (FUNC)ndis_read_pci }, { "NdisImmediateWritePciSlotInformation", (FUNC)ndis_write_pci }, { "NdisWriteErrorLogEntry", (FUNC)ndis_syslog }, { "NdisMStartBufferPhysicalMapping", (FUNC)ndis_vtophys_load }, { "NdisMCompleteBufferPhysicalMapping", (FUNC)ndis_vtophys_unload }, { "NdisMInitializeTimer", (FUNC)ndis_create_timer }, { "NdisInitializeTimer", (FUNC)ndis_init_timer }, { "NdisSetTimer", (FUNC)ndis_set_timer }, { "NdisMCancelTimer", (FUNC)ndis_cancel_timer }, { "NdisCancelTimer", (FUNC)ndis_cancel_timer }, { "NdisMSetPeriodicTimer", (FUNC)ndis_set_periodic_timer }, { "NdisMQueryAdapterResources", (FUNC)ndis_query_resources }, { "NdisMRegisterIoPortRange", (FUNC)ndis_register_ioport }, { "NdisMDeregisterIoPortRange", (FUNC)ndis_deregister_ioport }, { "NdisReadNetworkAddress", (FUNC)ndis_read_netaddr }, { "NdisQueryMapRegisterCount", (FUNC)ndis_mapreg_cnt }, { "NdisMAllocateMapRegisters", (FUNC)ndis_alloc_mapreg }, { "NdisMFreeMapRegisters", (FUNC)ndis_free_mapreg }, { "NdisMAllocateSharedMemory", (FUNC)ndis_alloc_sharedmem }, { "NdisMMapIoSpace", (FUNC)ndis_map_iospace }, { "NdisMUnmapIoSpace", (FUNC)ndis_unmap_iospace }, { "NdisGetCacheFillSize", (FUNC)ndis_cachefill }, { "NdisMGetDmaAlignment", (FUNC)ndis_dma_align }, { "NdisMInitializeScatterGatherDma", (FUNC)ndis_init_sc_dma }, { "NdisAllocatePacketPool", (FUNC)ndis_alloc_packetpool }, { "NdisAllocatePacketPoolEx", (FUNC)ndis_ex_alloc_packetpool }, { "NdisAllocatePacket", (FUNC)ndis_alloc_packet }, { "NdisFreePacket", (FUNC)ndis_release_packet }, { "NdisFreePacketPool", (FUNC)ndis_free_packetpool }, { "NdisDprAllocatePacket", (FUNC)ndis_alloc_packet }, { "NdisDprFreePacket", (FUNC)ndis_release_packet }, { "NdisAllocateBufferPool", (FUNC)ndis_alloc_bufpool }, { "NdisAllocateBuffer", (FUNC)ndis_alloc_buf }, { "NdisQueryBuffer", (FUNC)ndis_query_buf }, { "NdisQueryBufferSafe", (FUNC)ndis_query_buf_safe }, { "NdisBufferVirtualAddress", (FUNC)ndis_buf_vaddr }, { "NdisBufferVirtualAddressSafe", (FUNC)ndis_buf_vaddr_safe }, { "NdisBufferLength", (FUNC)ndis_buflen }, { "NdisFreeBuffer", (FUNC)ndis_release_buf }, { "NdisFreeBufferPool", (FUNC)ndis_free_bufpool }, { "NdisInterlockedIncrement", (FUNC)ndis_interlock_inc }, { "NdisInterlockedDecrement", (FUNC)ndis_interlock_dec }, { "NdisInitializeEvent", (FUNC)ndis_init_event }, { "NdisSetEvent", (FUNC)ndis_set_event }, { "NdisResetEvent", (FUNC)ndis_reset_event }, { "NdisWaitEvent", (FUNC)ndis_wait_event }, { "NdisUnicodeStringToAnsiString", (FUNC)ndis_unicode2ansi }, { "NdisMPciAssignResources", (FUNC)ndis_assign_pcirsrc }, { "NdisMFreeSharedMemory", (FUNC)ndis_free_sharedmem }, { "NdisMRegisterInterrupt", (FUNC)ndis_register_intr }, { "NdisMDeregisterInterrupt", (FUNC)ndis_deregister_intr }, { "NdisMRegisterAdapterShutdownHandler", (FUNC)ndis_register_shutdown }, { "NdisMDeregisterAdapterShutdownHandler", (FUNC)ndis_deregister_shutdown }, { "NDIS_BUFFER_TO_SPAN_PAGES", (FUNC)ndis_numpages }, { "NdisQueryBufferOffset", (FUNC)ndis_query_bufoffset }, { "NdisAdjustBufferLength", (FUNC)ndis_adjust_buflen }, { "NdisPacketPoolUsage", (FUNC)ndis_packetpool_use }, { "NdisMSleep", (FUNC)ndis_sleep }, { "NdisUnchainBufferAtFront", (FUNC)ndis_unchain_headbuf }, { "NdisReadPcmciaAttributeMemory", (FUNC)ndis_read_pccard_amem }, { "NdisWritePcmciaAttributeMemory", (FUNC)ndis_write_pccard_amem }, { "NdisOpenFile", (FUNC)ndis_open_file }, { "NdisMapFile", (FUNC)ndis_map_file }, { "NdisUnmapFile", (FUNC)ndis_unmap_file }, { "NdisCloseFile", (FUNC)ndis_close_file }, { "NdisMRegisterDevice", (FUNC)ndis_register_dev }, { "NdisMDeregisterDevice", (FUNC)ndis_deregister_dev }, /* * This last entry is a catch-all for any function we haven't * implemented yet. The PE import list patching routine will * use it for any function that doesn't have an explicit match * in this table. */ { NULL, (FUNC)dummy }, /* End of list. */ { NULL, NULL }, }; diff --git a/sys/dev/if_ndis/if_ndis.c b/sys/dev/if_ndis/if_ndis.c index 21ed9555baf6..d60d3b3e7114 100644 --- a/sys/dev/if_ndis/if_ndis.c +++ b/sys/dev/if_ndis/if_ndis.c @@ -1,2229 +1,2251 @@ /* * Copyright (c) 2003 * Bill Paul . All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Bill Paul. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include "opt_bdg.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include #include #include #include #include "ndis_driver_data.h" MODULE_DEPEND(ndis, pci, 1, 1, 1); MODULE_DEPEND(ndis, ether, 1, 1, 1); MODULE_DEPEND(ndis, wlan, 1, 1, 1); MODULE_DEPEND(ndis, ndisapi, 1, 1, 1); /* * Various supported device vendors/types and their names. * These are defined in the ndis_driver_data.h file. */ static struct ndis_type ndis_devs[] = { #ifdef NDIS_DEV_TABLE NDIS_DEV_TABLE #endif { 0, 0, 0, NULL } }; static int ndis_probe (device_t); static int ndis_attach (device_t); static int ndis_detach (device_t); static int ndis_suspend (device_t); static int ndis_resume (device_t); static __stdcall void ndis_txeof (ndis_handle, ndis_packet *, ndis_status); static __stdcall void ndis_rxeof (ndis_handle, ndis_packet **, uint32_t); static __stdcall void ndis_linksts (ndis_handle, ndis_status, void *, uint32_t); static __stdcall void ndis_linksts_done (ndis_handle); static void ndis_intr (void *); static void ndis_intrtask (void *); static void ndis_tick (void *); static void ndis_ticktask (void *); static void ndis_start (struct ifnet *); static void ndis_starttask (void *); static int ndis_ioctl (struct ifnet *, u_long, caddr_t); static int ndis_wi_ioctl_get (struct ifnet *, u_long, caddr_t); static int ndis_wi_ioctl_set (struct ifnet *, u_long, caddr_t); static void ndis_init (void *); static void ndis_stop (struct ndis_softc *); static void ndis_watchdog (struct ifnet *); static void ndis_shutdown (device_t); static int ndis_ifmedia_upd (struct ifnet *); static void ndis_ifmedia_sts (struct ifnet *, struct ifmediareq *); static int ndis_get_assoc (struct ndis_softc *, ndis_wlan_bssid_ex *); static int ndis_probe_offload (struct ndis_softc *); static int ndis_set_offload (struct ndis_softc *); static void ndis_getstate_80211 (struct ndis_softc *); static void ndis_setstate_80211 (struct ndis_softc *); static void ndis_media_status (struct ifnet *, struct ifmediareq *); static void ndis_setmulti (struct ndis_softc *); static void ndis_map_sclist (void *, bus_dma_segment_t *, int, bus_size_t, int); extern struct mtx_pool *ndis_mtxpool; static device_method_t ndis_methods[] = { /* Device interface */ DEVMETHOD(device_probe, ndis_probe), DEVMETHOD(device_attach, ndis_attach), DEVMETHOD(device_detach, ndis_detach), DEVMETHOD(device_shutdown, ndis_shutdown), DEVMETHOD(device_suspend, ndis_suspend), DEVMETHOD(device_resume, ndis_resume), { 0, 0 } }; static driver_t ndis_driver = { #ifdef NDIS_DEVNAME NDIS_DEVNAME, #else "ndis", #endif ndis_methods, sizeof(struct ndis_softc) }; static devclass_t ndis_devclass; #ifdef NDIS_MODNAME #define NDIS_MODNAME_OVERRIDE_PCI(x) \ DRIVER_MODULE(x, pci, ndis_driver, ndis_devclass, 0, 0) #define NDIS_MODNAME_OVERRIDE_CARDBUS(x) \ DRIVER_MODULE(x, cardbus, ndis_driver, ndis_devclass, 0, 0) NDIS_MODNAME_OVERRIDE_PCI(NDIS_MODNAME); NDIS_MODNAME_OVERRIDE_CARDBUS(NDIS_MODNAME); #else DRIVER_MODULE(ndis, pci, ndis_driver, ndis_devclass, 0, 0); DRIVER_MODULE(ndis, cardbus, ndis_driver, ndis_devclass, 0, 0); #endif /* * Program the 64-bit multicast hash filter. */ static void ndis_setmulti(sc) struct ndis_softc *sc; { struct ifnet *ifp; struct ifmultiaddr *ifma; int len, mclistsz, error; uint8_t *mclist; ifp = &sc->arpcom.ac_if; if (!(ifp->if_flags & IFF_UP)) return; if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) { sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST; len = sizeof(sc->ndis_filter); error = ndis_set_info(sc, OID_GEN_CURRENT_PACKET_FILTER, &sc->ndis_filter, &len); if (error) device_printf (sc->ndis_dev, "set filter failed: %d\n", error); return; } len = sizeof(mclistsz); ndis_get_info(sc, OID_802_3_MAXIMUM_LIST_SIZE, &mclistsz, &len); mclist = malloc(ETHER_ADDR_LEN * mclistsz, M_TEMP, M_NOWAIT|M_ZERO); if (mclist == NULL) { sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST; goto out; } sc->ndis_filter |= NDIS_PACKET_TYPE_MULTICAST; len = 0; TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { if (ifma->ifma_addr->sa_family != AF_LINK) continue; bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr), mclist + (ETHER_ADDR_LEN * len), ETHER_ADDR_LEN); len++; if (len > mclistsz) { sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST; sc->ndis_filter &= ~NDIS_PACKET_TYPE_MULTICAST; goto out; } } len = len * ETHER_ADDR_LEN; error = ndis_set_info(sc, OID_802_3_MULTICAST_LIST, mclist, &len); if (error) { device_printf (sc->ndis_dev, "set mclist failed: %d\n", error); sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST; sc->ndis_filter &= ~NDIS_PACKET_TYPE_MULTICAST; } out: free(mclist, M_TEMP); len = sizeof(sc->ndis_filter); error = ndis_set_info(sc, OID_GEN_CURRENT_PACKET_FILTER, &sc->ndis_filter, &len); if (error) device_printf (sc->ndis_dev, "set filter failed: %d\n", error); return; } /* * Probe for an NDIS device. Check the PCI vendor and device * IDs against our list and return a device name if we find a match. */ static int ndis_probe(dev) device_t dev; { struct ndis_type *t; t = ndis_devs; while(t->ndis_name != NULL) { if ((pci_get_vendor(dev) == t->ndis_vid) && (pci_get_device(dev) == t->ndis_did) && ((pci_read_config(dev, PCIR_SUBVEND_0, 4) == t->ndis_subsys) || t->ndis_subsys == 0)) { device_set_desc(dev, t->ndis_name); return(0); } t++; } return(ENXIO); } static int ndis_set_offload(sc) struct ndis_softc *sc; { ndis_task_offload *nto; ndis_task_offload_hdr *ntoh; ndis_task_tcpip_csum *nttc; struct ifnet *ifp; int len, error; ifp = &sc->arpcom.ac_if; if (!(ifp->if_flags & IFF_UP)) return(EINVAL); /* See if there's anything to set. */ error = ndis_probe_offload(sc); if (error) return(error); if (sc->ndis_hwassist == 0 && ifp->if_capabilities == 0) return(0); len = sizeof(ndis_task_offload_hdr) + sizeof(ndis_task_offload) + sizeof(ndis_task_tcpip_csum); ntoh = malloc(len, M_TEMP, M_NOWAIT|M_ZERO); if (ntoh == NULL) return(ENOMEM); ntoh->ntoh_vers = NDIS_TASK_OFFLOAD_VERSION; ntoh->ntoh_len = sizeof(ndis_task_offload_hdr); ntoh->ntoh_offset_firsttask = sizeof(ndis_task_offload_hdr); ntoh->ntoh_encapfmt.nef_encaphdrlen = sizeof(struct ether_header); ntoh->ntoh_encapfmt.nef_encap = NDIS_ENCAP_IEEE802_3; ntoh->ntoh_encapfmt.nef_flags = NDIS_ENCAPFLAG_FIXEDHDRLEN; nto = (ndis_task_offload *)((char *)ntoh + ntoh->ntoh_offset_firsttask); nto->nto_vers = NDIS_TASK_OFFLOAD_VERSION; nto->nto_len = sizeof(ndis_task_offload); nto->nto_task = NDIS_TASK_TCPIP_CSUM; nto->nto_offset_nexttask = 0; nto->nto_taskbuflen = sizeof(ndis_task_tcpip_csum); nttc = (ndis_task_tcpip_csum *)nto->nto_taskbuf; if (ifp->if_capenable & IFCAP_TXCSUM) nttc->nttc_v4tx = sc->ndis_v4tx; if (ifp->if_capenable & IFCAP_RXCSUM) nttc->nttc_v4rx = sc->ndis_v4rx; error = ndis_set_info(sc, OID_TCP_TASK_OFFLOAD, ntoh, &len); free(ntoh, M_TEMP); return(error); } static int ndis_probe_offload(sc) struct ndis_softc *sc; { ndis_task_offload *nto; ndis_task_offload_hdr *ntoh; ndis_task_tcpip_csum *nttc = NULL; struct ifnet *ifp; int len, error, dummy; ifp = &sc->arpcom.ac_if; len = sizeof(dummy); error = ndis_get_info(sc, OID_TCP_TASK_OFFLOAD, &dummy, &len); if (error != ENOSPC) return(error); ntoh = malloc(len, M_TEMP, M_NOWAIT|M_ZERO); if (ntoh == NULL) return(ENOMEM); ntoh->ntoh_vers = NDIS_TASK_OFFLOAD_VERSION; ntoh->ntoh_len = sizeof(ndis_task_offload_hdr); ntoh->ntoh_encapfmt.nef_encaphdrlen = sizeof(struct ether_header); ntoh->ntoh_encapfmt.nef_encap = NDIS_ENCAP_IEEE802_3; ntoh->ntoh_encapfmt.nef_flags = NDIS_ENCAPFLAG_FIXEDHDRLEN; error = ndis_get_info(sc, OID_TCP_TASK_OFFLOAD, ntoh, &len); if (error) { free(ntoh, M_TEMP); return(error); } if (ntoh->ntoh_vers != NDIS_TASK_OFFLOAD_VERSION) { free(ntoh, M_TEMP); return(EINVAL); } nto = (ndis_task_offload *)((char *)ntoh + ntoh->ntoh_offset_firsttask); while (1) { switch (nto->nto_task) { case NDIS_TASK_TCPIP_CSUM: nttc = (ndis_task_tcpip_csum *)nto->nto_taskbuf; break; /* Don't handle these yet. */ case NDIS_TASK_IPSEC: case NDIS_TASK_TCP_LARGESEND: default: break; } if (nto->nto_offset_nexttask == 0) break; nto = (ndis_task_offload *)((char *)nto + nto->nto_offset_nexttask); } if (nttc == NULL) { free(ntoh, M_TEMP); return(ENOENT); } sc->ndis_v4tx = nttc->nttc_v4tx; sc->ndis_v4rx = nttc->nttc_v4rx; if (nttc->nttc_v4tx & NDIS_TCPSUM_FLAGS_IP_CSUM) sc->ndis_hwassist |= CSUM_IP; if (nttc->nttc_v4tx & NDIS_TCPSUM_FLAGS_TCP_CSUM) sc->ndis_hwassist |= CSUM_TCP; if (nttc->nttc_v4tx & NDIS_TCPSUM_FLAGS_UDP_CSUM) sc->ndis_hwassist |= CSUM_UDP; if (sc->ndis_hwassist) ifp->if_capabilities |= IFCAP_TXCSUM; if (nttc->nttc_v4rx & NDIS_TCPSUM_FLAGS_IP_CSUM) ifp->if_capabilities |= IFCAP_RXCSUM; if (nttc->nttc_v4rx & NDIS_TCPSUM_FLAGS_TCP_CSUM) ifp->if_capabilities |= IFCAP_RXCSUM; if (nttc->nttc_v4rx & NDIS_TCPSUM_FLAGS_UDP_CSUM) ifp->if_capabilities |= IFCAP_RXCSUM; free(ntoh, M_TEMP); return(0); } /* * Attach the interface. Allocate softc structures, do ifmedia * setup and ethernet/BPF attach. */ static int ndis_attach(dev) device_t dev; { u_char eaddr[ETHER_ADDR_LEN]; struct ndis_softc *sc; struct ifnet *ifp = NULL; int unit, error = 0, rid, len; void *img; struct ndis_type *t; int i, devidx = 0, defidx = 0; struct resource_list *rl; struct resource_list_entry *rle; sc = device_get_softc(dev); unit = device_get_unit(dev); sc->ndis_dev = dev; sc->ndis_mtx = mtx_pool_alloc(ndis_mtxpool); sc->ndis_intrmtx = mtx_pool_alloc(ndis_mtxpool); /* * Map control/status registers. */ pci_enable_busmaster(dev); rl = BUS_GET_RESOURCE_LIST(device_get_parent(dev), dev); if (rl != NULL) { SLIST_FOREACH(rle, rl, link) { switch (rle->type) { case SYS_RES_IOPORT: sc->ndis_io_rid = rle->rid; sc->ndis_res_io = bus_alloc_resource(dev, SYS_RES_IOPORT, &sc->ndis_io_rid, 0, ~0, 1, RF_ACTIVE); if (sc->ndis_res_io == NULL) { device_printf(dev, "couldn't map iospace\n"); error = ENXIO; goto fail; } break; case SYS_RES_MEMORY: if (sc->ndis_res_altmem != NULL && sc->ndis_res_mem != NULL) { device_printf(dev, "too many memory resources\n"); error = ENXIO; goto fail; } if (rle->rid == PCIR_BAR(2)) { sc->ndis_altmem_rid = rle->rid; sc->ndis_res_altmem = bus_alloc_resource(dev, SYS_RES_MEMORY, &sc->ndis_altmem_rid, 0, ~0, 1, RF_ACTIVE); if (sc->ndis_res_altmem == NULL) { device_printf(dev, "couldn't map alt " "memory\n"); error = ENXIO; goto fail; } } else { sc->ndis_mem_rid = rle->rid; sc->ndis_res_mem = bus_alloc_resource(dev, SYS_RES_MEMORY, &sc->ndis_mem_rid, 0, ~0, 1, RF_ACTIVE); if (sc->ndis_res_mem == NULL) { device_printf(dev, "couldn't map memory\n"); error = ENXIO; goto fail; } } break; case SYS_RES_IRQ: rid = rle->rid; sc->ndis_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1, RF_SHAREABLE | RF_ACTIVE); if (sc->ndis_irq == NULL) { device_printf(dev, "couldn't map interrupt\n"); error = ENXIO; goto fail; } break; default: break; } sc->ndis_rescnt++; } } /* * Hook interrupt early, since calling the driver's * init routine may trigger an interrupt. */ error = bus_setup_intr(dev, sc->ndis_irq, INTR_TYPE_NET, ndis_intr, sc, &sc->ndis_intrhand); if (error) { device_printf(dev, "couldn't set up irq\n"); goto fail; } /* * Allocate the parent bus DMA tag appropriate for PCI. */ #define NDIS_NSEG_NEW 32 error = bus_dma_tag_create(NULL, /* parent */ 1, 0, /* alignment, boundary */ BUS_SPACE_MAXADDR_32BIT,/* lowaddr */ BUS_SPACE_MAXADDR, /* highaddr */ NULL, NULL, /* filter, filterarg */ MAXBSIZE, NDIS_NSEG_NEW,/* maxsize, nsegments */ BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */ BUS_DMA_ALLOCNOW, /* flags */ NULL, NULL, /* lockfunc, lockarg */ &sc->ndis_parent_tag); if (error) goto fail; img = drv_data; sc->ndis_regvals = ndis_regvals; sc->ndis_iftype = PCIBus; /* Figure out exactly which device we matched. */ t = ndis_devs; while(t->ndis_name != NULL) { if ((pci_get_vendor(dev) == t->ndis_vid) && (pci_get_device(dev) == t->ndis_did)) { if (t->ndis_subsys == 0) defidx = devidx; else { if (t->ndis_subsys == pci_read_config(dev, PCIR_SUBVEND_0, 4)) break; } } t++; devidx++; } if (ndis_devs[devidx].ndis_name == NULL) sc->ndis_devidx = defidx; else sc->ndis_devidx = devidx; sysctl_ctx_init(&sc->ndis_ctx); /* Create sysctl registry nodes */ ndis_create_sysctls(sc); /* Set up driver image in memory. */ ndis_load_driver((vm_offset_t)img, sc); /* Tell the user what version of the API the driver is using. */ device_printf(dev, "NDIS API version: %d.%d\n", sc->ndis_chars.nmc_version_major, sc->ndis_chars.nmc_version_minor); /* Do resource conversion. */ ndis_convert_res(sc); /* Install our RX and TX interrupt handlers. */ sc->ndis_block.nmb_senddone_func = ndis_txeof; sc->ndis_block.nmb_pktind_func = ndis_rxeof; /* Call driver's init routine. */ if (ndis_init_nic(sc)) { device_printf (dev, "init handler failed\n"); error = ENXIO; goto fail; } /* Reset the adapter. */ ndis_reset_nic(sc); /* * Get station address from the driver. */ len = sizeof(eaddr); ndis_get_info(sc, OID_802_3_CURRENT_ADDRESS, &eaddr, &len); sc->ndis_unit = unit; bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN); /* * Figure out of we're allowed to use multipacket sends * with this driver, and if so, how many. */ - if (sc->ndis_chars.nmc_sendsingle_func) + if (sc->ndis_chars.nmc_sendsingle_func && + sc->ndis_chars.nmc_sendmulti_func == NULL) { sc->ndis_maxpkts = 1; - else { + } else { len = sizeof(sc->ndis_maxpkts); ndis_get_info(sc, OID_GEN_MAXIMUM_SEND_PACKETS, &sc->ndis_maxpkts, &len); - sc->ndis_txarray = malloc(sizeof(ndis_packet *) * - sc->ndis_maxpkts, M_DEVBUF, M_NOWAIT|M_ZERO); } + sc->ndis_txarray = malloc(sizeof(ndis_packet *) * + sc->ndis_maxpkts, M_DEVBUF, M_NOWAIT|M_ZERO); + sc->ndis_txpending = sc->ndis_maxpkts; sc->ndis_oidcnt = 0; /* Get supported oid list. */ ndis_get_supported_oids(sc, &sc->ndis_oids, &sc->ndis_oidcnt); /* If the NDIS module requested scatter/gather, init maps. */ if (sc->ndis_sc) ndis_init_dma(sc); /* * See if the OID_802_11_CONFIGURATION OID is * supported by this driver. If it is, then this an 802.11 * wireless driver, and we should set up media for wireless. */ for (i = 0; i < sc->ndis_oidcnt; i++) { if (sc->ndis_oids[i] == OID_802_11_CONFIGURATION) { sc->ndis_80211++; break; } } /* Check for task offload support. */ ndis_probe_offload(sc); /* * An NDIS device was detected. Inform the world. */ device_printf(dev, "%s address: %6D\n", sc->ndis_80211 ? "802.11" : "Ethernet", eaddr, ":"); ifp = &sc->arpcom.ac_if; ifp->if_softc = sc; if_initname(ifp, device_get_name(dev), device_get_unit(dev)); ifp->if_mtu = ETHERMTU; ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; ifp->if_ioctl = ndis_ioctl; ifp->if_output = ether_output; ifp->if_start = ndis_start; ifp->if_watchdog = ndis_watchdog; ifp->if_init = ndis_init; ifp->if_baudrate = 10000000; ifp->if_snd.ifq_maxlen = 50; ifp->if_capenable = ifp->if_capabilities; ifp->if_hwassist = sc->ndis_hwassist; /* Do media setup */ if (sc->ndis_80211) { struct ieee80211com *ic = (void *)ifp; ndis_80211_config config; ndis_80211_rates rates; struct ndis_80211_nettype_list *ntl; uint32_t arg; int r; ic->ic_phytype = IEEE80211_T_DS; ic->ic_opmode = IEEE80211_M_STA; ic->ic_caps = IEEE80211_C_IBSS; ic->ic_state = IEEE80211_S_ASSOC; ic->ic_modecaps = (1<ntl_items; i++) { switch (ntl->ntl_type[i]) { case NDIS_80211_NETTYPE_11FH: ic->ic_modecaps |= (1<ic_modecaps |= (1<ic_modecaps |= (1<ic_modecaps |= (1<ic_sup_rates[x].rs_rates[ic->ic_sup_rates[x].rs_nrates] = (y) #define INCRATE(x) \ ic->ic_sup_rates[x].rs_nrates++ ic->ic_curmode = IEEE80211_MODE_AUTO; if (ic->ic_modecaps & (1<ic_sup_rates[IEEE80211_MODE_11A].rs_nrates = 0; if (ic->ic_modecaps & (1<ic_sup_rates[IEEE80211_MODE_11B].rs_nrates = 0; if (ic->ic_modecaps & (1<ic_sup_rates[IEEE80211_MODE_11G].rs_nrates = 0; for (i = 0; i < len; i++) { switch (rates[i] & IEEE80211_RATE_VAL) { case 2: case 4: case 11: case 10: case 22: if (!(ic->ic_modecaps & (1<ic_modecaps |= (1<ic_sup_rates[IEEE80211_MODE_11B]. rs_nrates = 0; } SETRATE(IEEE80211_MODE_11B, rates[i]); INCRATE(IEEE80211_MODE_11B); break; default: if (ic->ic_modecaps & (1<ic_modecaps & (1<ic_modecaps & (1<ic_modecaps & (1<ic_sup_rates[IEEE80211_MODE_11G].rs_nrates) chanflag |= IEEE80211_CHAN_G; if (i <= 14) chanflag |= IEEE80211_CHAN_B; if (chanflag == 0) break; ic->ic_channels[i].ic_freq = ieee80211_ieee2mhz(i, chanflag); ic->ic_channels[i].ic_flags = chanflag; } i = sizeof(arg); r = ndis_get_info(sc, OID_802_11_WEP_STATUS, &arg, &i); if (arg != NDIS_80211_WEPSTAT_NOTSUPPORTED) ic->ic_caps |= IEEE80211_C_WEP; i = sizeof(arg); r = ndis_get_info(sc, OID_802_11_POWER_MODE, &arg, &i); if (r == 0) ic->ic_caps |= IEEE80211_C_PMGT; i = sizeof(config); + config.nc_length = i; + config.nc_fhconfig.ncf_length = sizeof(ndis_80211_config_fh); r = ndis_get_info(sc, OID_802_11_CONFIGURATION, &config, &i); if (r == 0) { int chan; chan = ieee80211_mhz2ieee(config.nc_dsconfig / 1000, 0); if (chan < 0 || chan >= IEEE80211_CHAN_MAX) { ic->ic_ibss_chan = &ic->ic_channels[1]; } else ic->ic_ibss_chan = &ic->ic_channels[chan]; } else { device_printf(sc->ndis_dev, "couldn't retrieve " "channel info: %d\n", r); ic->ic_ibss_chan = &ic->ic_channels[1]; } bcopy(eaddr, &ic->ic_myaddr, sizeof(eaddr)); ieee80211_ifattach(ifp); ieee80211_media_init(ifp, ieee80211_media_change, ndis_media_status); ic->ic_bss->ni_chan = ic->ic_ibss_chan; } else { ifmedia_init(&sc->ifmedia, IFM_IMASK, ndis_ifmedia_upd, ndis_ifmedia_sts); ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_T, 0, NULL); ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_T|IFM_FDX, 0, NULL); ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_100_TX, 0, NULL); ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_100_TX|IFM_FDX, 0, NULL); ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_AUTO, 0, NULL); ifmedia_set(&sc->ifmedia, IFM_ETHER|IFM_AUTO); ether_ifattach(ifp, eaddr); } /* Override the status handler so we can detect link changes. */ sc->ndis_block.nmb_status_func = ndis_linksts; sc->ndis_block.nmb_statusdone_func = ndis_linksts_done; fail: if (error) ndis_detach(dev); else { /* We're done talking to the NIC for now; halt it. */ ifp->if_flags |= IFF_UP; ndis_halt_nic(sc); ifp->if_flags &= ~IFF_UP; } return(error); } /* * Shutdown hardware and free up resources. This can be called any * time after the mutex has been initialized. It is called in both * the error case in attach and the normal detach case so it needs * to be careful about only freeing resources that have actually been * allocated. */ static int ndis_detach(dev) device_t dev; { struct ndis_softc *sc; struct ifnet *ifp; sc = device_get_softc(dev); KASSERT(mtx_initialized(sc->ndis_mtx), ("ndis mutex not initialized")); KASSERT(mtx_initialized(sc->ndis_intrmtx), ("ndis interrupt mutex not initialized")); NDIS_LOCK(sc); ifp = &sc->arpcom.ac_if; ifp->if_flags &= ~IFF_UP; if (device_is_attached(dev)) { NDIS_UNLOCK(sc); ndis_stop(sc); if (sc->ndis_80211) ieee80211_ifdetach(ifp); else ether_ifdetach(ifp); } else NDIS_UNLOCK(sc); bus_generic_detach(dev); if (sc->ndis_intrhand) bus_teardown_intr(dev, sc->ndis_irq, sc->ndis_intrhand); if (sc->ndis_irq) bus_release_resource(dev, SYS_RES_IRQ, 0, sc->ndis_irq); if (sc->ndis_res_io) bus_release_resource(dev, SYS_RES_IOPORT, sc->ndis_io_rid, sc->ndis_res_io); if (sc->ndis_res_mem) bus_release_resource(dev, SYS_RES_MEMORY, sc->ndis_mem_rid, sc->ndis_res_mem); if (sc->ndis_res_altmem) bus_release_resource(dev, SYS_RES_MEMORY, sc->ndis_altmem_rid, sc->ndis_res_altmem); if (sc->ndis_sc) ndis_destroy_dma(sc); ndis_unload_driver((void *)ifp); bus_dma_tag_destroy(sc->ndis_parent_tag); sysctl_ctx_free(&sc->ndis_ctx); return(0); } static int ndis_suspend(dev) device_t dev; { struct ndis_softc *sc; struct ifnet *ifp; sc = device_get_softc(dev); ifp = &sc->arpcom.ac_if; #ifdef notdef if (ifp->if_flags & IFF_UP) ndis_stop(sc); #endif return(0); } static int ndis_resume(dev) device_t dev; { struct ndis_softc *sc; struct ifnet *ifp; sc = device_get_softc(dev); ifp = &sc->arpcom.ac_if; if (ifp->if_flags & IFF_UP) ndis_init(sc); return(0); } /* * A frame has been uploaded: pass the resulting mbuf chain up to * the higher level protocols. * * When handling received NDIS packets, the 'status' field in the * out-of-band portion of the ndis_packet has special meaning. In the * most common case, the underlying NDIS driver will set this field * to NDIS_STATUS_SUCCESS, which indicates that it's ok for us to * take posession of it. We then change the status field to * NDIS_STATUS_PENDING to tell the driver that we now own the packet, * and that we will return it at some point in the future via the * return packet handler. * * If the driver hands us a packet with a status of NDIS_STATUS_RESOURCES, * this means the driver is running out of packet/buffer resources and * wants to maintain ownership of the packet. In this case, we have to * copy the packet data into local storage and let the driver keep the * packet. */ __stdcall static void ndis_rxeof(adapter, packets, pktcnt) ndis_handle adapter; ndis_packet **packets; uint32_t pktcnt; { struct ndis_softc *sc; ndis_miniport_block *block; ndis_packet *p; uint32_t s; ndis_tcpip_csum *csum; struct ifnet *ifp; struct mbuf *m0, *m; int i; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)(block->nmb_ifp); ifp = block->nmb_ifp; for (i = 0; i < pktcnt; i++) { p = packets[i]; /* Stash the softc here so ptom can use it. */ p->np_softc = sc; if (ndis_ptom(&m0, p)) { device_printf (sc->ndis_dev, "ptom failed\n"); if (p->np_oob.npo_status == NDIS_STATUS_SUCCESS) ndis_return_packet(sc, p); } else { if (p->np_oob.npo_status == NDIS_STATUS_RESOURCES) { m = m_dup(m0, M_DONTWAIT); m_freem(m0); if (m == NULL) ifp->if_ierrors++; else m0 = m; } else p->np_oob.npo_status = NDIS_STATUS_PENDING; m0->m_pkthdr.rcvif = ifp; ifp->if_ipackets++; /* Deal with checksum offload. */ if (ifp->if_capenable & IFCAP_RXCSUM && p->np_ext.npe_info[ndis_tcpipcsum_info] != NULL) { s = (uintptr_t) p->np_ext.npe_info[ndis_tcpipcsum_info]; csum = (ndis_tcpip_csum *)&s; if (csum->u.ntc_rxflags & NDIS_RXCSUM_IP_PASSED) m0->m_pkthdr.csum_flags |= CSUM_IP_CHECKED|CSUM_IP_VALID; if (csum->u.ntc_rxflags & (NDIS_RXCSUM_TCP_PASSED | NDIS_RXCSUM_UDP_PASSED)) { m0->m_pkthdr.csum_flags |= CSUM_DATA_VALID|CSUM_PSEUDO_HDR; m0->m_pkthdr.csum_data = 0xFFFF; } } (*ifp->if_input)(ifp, m0); } } return; } /* * A frame was downloaded to the chip. It's safe for us to clean up * the list buffers. */ __stdcall static void ndis_txeof(adapter, packet, status) ndis_handle adapter; ndis_packet *packet; ndis_status status; { struct ndis_softc *sc; ndis_miniport_block *block; struct ifnet *ifp; int idx; struct mbuf *m; block = (ndis_miniport_block *)adapter; sc = (struct ndis_softc *)block->nmb_ifp; ifp = block->nmb_ifp; m = packet->np_m0; idx = packet->np_txidx; if (sc->ndis_sc) bus_dmamap_unload(sc->ndis_ttag, sc->ndis_tmaps[idx]); ndis_free_packet(packet); m_freem(m); NDIS_LOCK(sc); sc->ndis_txarray[idx] = NULL; sc->ndis_txpending++; if (status == NDIS_STATUS_SUCCESS) ifp->if_opackets++; else ifp->if_oerrors++; ifp->if_timer = 0; ifp->if_flags &= ~IFF_OACTIVE; NDIS_UNLOCK(sc); ndis_sched(ndis_starttask, ifp, NDIS_TASKQUEUE); return; } __stdcall static void ndis_linksts(adapter, status, sbuf, slen) ndis_handle adapter; ndis_status status; void *sbuf; uint32_t slen; { ndis_miniport_block *block; block = adapter; block->nmb_getstat = status; return; } __stdcall static void ndis_linksts_done(adapter) ndis_handle adapter; { ndis_miniport_block *block; struct ndis_softc *sc; struct ifnet *ifp; block = adapter; ifp = block->nmb_ifp; sc = ifp->if_softc; if (!(ifp->if_flags & IFF_UP)) return; switch (block->nmb_getstat) { case NDIS_STATUS_MEDIA_CONNECT: ndis_sched(ndis_ticktask, sc, NDIS_TASKQUEUE); ndis_sched(ndis_starttask, ifp, NDIS_TASKQUEUE); break; case NDIS_STATUS_MEDIA_DISCONNECT: if (sc->ndis_80211) ndis_getstate_80211(sc); ndis_sched(ndis_ticktask, sc, NDIS_TASKQUEUE); break; default: break; } return; } static void ndis_intrtask(arg) void *arg; { struct ndis_softc *sc; struct ifnet *ifp; sc = arg; ifp = &sc->arpcom.ac_if; ndis_intrhand(sc); mtx_pool_lock(ndis_mtxpool, sc->ndis_intrmtx); ndis_enable_intr(sc); mtx_pool_unlock(ndis_mtxpool, sc->ndis_intrmtx); return; } static void ndis_intr(arg) void *arg; { struct ndis_softc *sc; struct ifnet *ifp; int is_our_intr = 0; int call_isr = 0; sc = arg; ifp = &sc->arpcom.ac_if; if (!(ifp->if_flags & IFF_UP) && sc->ndis_block.nmb_miniportadapterctx == NULL) return; mtx_pool_lock(ndis_mtxpool, sc->ndis_intrmtx); if (sc->ndis_block.nmb_interrupt->ni_isrreq == TRUE) ndis_isr(sc, &is_our_intr, &call_isr); else { ndis_disable_intr(sc); call_isr = 1; } mtx_pool_unlock(ndis_mtxpool, sc->ndis_intrmtx); if ((is_our_intr || call_isr) && (ifp->if_flags & IFF_UP)) ndis_sched(ndis_intrtask, ifp, NDIS_SWI); return; } static void ndis_tick(xsc) void *xsc; { struct ndis_softc *sc; sc = xsc; ndis_sched(ndis_ticktask, sc, NDIS_TASKQUEUE); sc->ndis_stat_ch = timeout(ndis_tick, sc, hz * sc->ndis_block.nmb_checkforhangsecs); } static void ndis_ticktask(xsc) void *xsc; { struct ndis_softc *sc; __stdcall ndis_checkforhang_handler hangfunc; uint8_t rval; ndis_media_state linkstate; int error, len; sc = xsc; len = sizeof(linkstate); error = ndis_get_info(sc, OID_GEN_MEDIA_CONNECT_STATUS, (void *)&linkstate, &len); NDIS_LOCK(sc); if (sc->ndis_link == 0 && linkstate == nmc_connected) { device_printf(sc->ndis_dev, "link up\n"); sc->ndis_link = 1; if (sc->ndis_80211) ndis_getstate_80211(sc); } if (sc->ndis_link == 1 && linkstate == nmc_disconnected) { device_printf(sc->ndis_dev, "link down\n"); sc->ndis_link = 0; } NDIS_UNLOCK(sc); hangfunc = sc->ndis_chars.nmc_checkhang_func; if (hangfunc != NULL) { rval = hangfunc(sc->ndis_block.nmb_miniportadapterctx); if (rval == TRUE) ndis_reset_nic(sc); } return; } static void ndis_map_sclist(arg, segs, nseg, mapsize, error) void *arg; bus_dma_segment_t *segs; int nseg; bus_size_t mapsize; int error; { struct ndis_sc_list *sclist; int i; if (error || arg == NULL) return; sclist = arg; sclist->nsl_frags = nseg; for (i = 0; i < nseg; i++) { sclist->nsl_elements[i].nse_addr.np_quad = segs[i].ds_addr; sclist->nsl_elements[i].nse_len = segs[i].ds_len; } return; } static void ndis_starttask(arg) void *arg; { struct ifnet *ifp; ifp = arg; if (ifp->if_snd.ifq_head != NULL) ndis_start(ifp); return; } /* * Main transmit routine. To make NDIS drivers happy, we need to * transform mbuf chains into NDIS packets and feed them to the * send packet routines. Most drivers allow you to send several * packets at once (up to the maxpkts limit). Unfortunately, rather * that accepting them in the form of a linked list, they expect * a contiguous array of pointers to packets. * * For those drivers which use the NDIS scatter/gather DMA mechanism, * we need to perform busdma work here. Those that use map registers * will do the mapping themselves on a buffer by buffer basis. */ static void ndis_start(ifp) struct ifnet *ifp; { struct ndis_softc *sc; struct mbuf *m = NULL; ndis_packet **p0 = NULL, *p = NULL; ndis_tcpip_csum *csum; int pcnt = 0; sc = ifp->if_softc; NDIS_LOCK(sc); if (!sc->ndis_link || ifp->if_flags & IFF_OACTIVE) { NDIS_UNLOCK(sc); return; } p0 = &sc->ndis_txarray[sc->ndis_txidx]; while(sc->ndis_txpending) { IF_DEQUEUE(&ifp->if_snd, m); if (m == NULL) break; sc->ndis_txarray[sc->ndis_txidx] = NULL; if (ndis_mtop(m, &sc->ndis_txarray[sc->ndis_txidx])) { NDIS_UNLOCK(sc); IF_PREPEND(&ifp->if_snd, m); return; } /* * Save pointer to original mbuf * so we can free it later. */ p = sc->ndis_txarray[sc->ndis_txidx]; p->np_txidx = sc->ndis_txidx; p->np_m0 = m; p->np_oob.npo_status = NDIS_STATUS_PENDING; /* * Do scatter/gather processing, if driver requested it. */ if (sc->ndis_sc) { bus_dmamap_load_mbuf(sc->ndis_ttag, sc->ndis_tmaps[sc->ndis_txidx], m, ndis_map_sclist, &p->np_sclist, BUS_DMA_NOWAIT); bus_dmamap_sync(sc->ndis_ttag, sc->ndis_tmaps[sc->ndis_txidx], BUS_DMASYNC_PREREAD); p->np_ext.npe_info[ndis_sclist_info] = &p->np_sclist; } /* Handle checksum offload. */ if (ifp->if_capenable & IFCAP_TXCSUM && m->m_pkthdr.csum_flags) { csum = (ndis_tcpip_csum *) &p->np_ext.npe_info[ndis_tcpipcsum_info]; csum->u.ntc_txflags = NDIS_TXCSUM_DO_IPV4; if (m->m_pkthdr.csum_flags & CSUM_IP) csum->u.ntc_txflags |= NDIS_TXCSUM_DO_IP; if (m->m_pkthdr.csum_flags & CSUM_TCP) csum->u.ntc_txflags |= NDIS_TXCSUM_DO_TCP; if (m->m_pkthdr.csum_flags & CSUM_UDP) csum->u.ntc_txflags |= NDIS_TXCSUM_DO_UDP; p->np_private.npp_flags = NDIS_PROTOCOL_ID_TCP_IP; } NDIS_INC(sc); sc->ndis_txpending--; pcnt++; /* * If there's a BPF listener, bounce a copy of this frame * to him. */ BPF_MTAP(ifp, m); /* * The array that p0 points to must appear contiguous, * so we must not wrap past the end of sc->ndis_txarray[]. * If it looks like we're about to wrap, break out here * so the this batch of packets can be transmitted, then * wait for txeof to ask us to send the rest. */ if (sc->ndis_txidx == 0) break; } if (sc->ndis_txpending == 0) ifp->if_flags |= IFF_OACTIVE; /* * Set a timeout in case the chip goes out to lunch. */ ifp->if_timer = 5; NDIS_UNLOCK(sc); - ndis_send_packets(sc, p0, pcnt); + if (sc->ndis_maxpkts == 1) + ndis_send_packet(sc, p); + else + ndis_send_packets(sc, p0, pcnt); return; } static void ndis_init(xsc) void *xsc; { struct ndis_softc *sc = xsc; struct ifnet *ifp = &sc->arpcom.ac_if; int i, error; /* * Avoid reintializing the link unnecessarily. * This should be dealt with in a better way by * fixing the upper layer modules so they don't * call ifp->if_init() quite as often. */ if (sc->ndis_link && sc->ndis_skip) return; /* * Cancel pending I/O and free all RX/TX buffers. */ ndis_reset_nic(sc); ndis_stop(sc); ndis_init_nic(sc); /* Init our MAC address */ /* Program the packet filter */ sc->ndis_filter = NDIS_PACKET_TYPE_DIRECTED; if (ifp->if_flags & IFF_BROADCAST) sc->ndis_filter |= NDIS_PACKET_TYPE_BROADCAST; if (ifp->if_flags & IFF_PROMISC) sc->ndis_filter |= NDIS_PACKET_TYPE_PROMISCUOUS; i = sizeof(sc->ndis_filter); error = ndis_set_info(sc, OID_GEN_CURRENT_PACKET_FILTER, &sc->ndis_filter, &i); if (error) device_printf (sc->ndis_dev, "set filter failed: %d\n", error); /* * Program the multicast filter, if necessary. */ ndis_setmulti(sc); /* Setup task offload. */ ndis_set_offload(sc); /* Enable interrupts. */ ndis_enable_intr(sc); if (sc->ndis_80211) ndis_setstate_80211(sc); NDIS_LOCK(sc); sc->ndis_txidx = 0; sc->ndis_txpending = sc->ndis_maxpkts; sc->ndis_link = 0; ifp->if_flags |= IFF_RUNNING; ifp->if_flags &= ~IFF_OACTIVE; NDIS_UNLOCK(sc); /* * Some drivers don't set this value. The NDIS spec says * the default checkforhang timeout is approximately 2 * seconds. */ if (sc->ndis_block.nmb_checkforhangsecs == 0) sc->ndis_block.nmb_checkforhangsecs = 2; sc->ndis_stat_ch = timeout(ndis_tick, sc, hz * sc->ndis_block.nmb_checkforhangsecs); return; } /* * Set media options. */ static int ndis_ifmedia_upd(ifp) struct ifnet *ifp; { struct ndis_softc *sc; sc = ifp->if_softc; if (ifp->if_flags & IFF_UP) ndis_init(sc); return(0); } /* * Report current media status. */ static void ndis_ifmedia_sts(ifp, ifmr) struct ifnet *ifp; struct ifmediareq *ifmr; { struct ndis_softc *sc; uint32_t media_info; ndis_media_state linkstate; int error, len; ifmr->ifm_status = IFM_AVALID; ifmr->ifm_active = IFM_ETHER; if (!(ifp->if_flags & IFF_UP)) return; sc = ifp->if_softc; len = sizeof(linkstate); error = ndis_get_info(sc, OID_GEN_MEDIA_CONNECT_STATUS, (void *)&linkstate, &len); len = sizeof(media_info); error = ndis_get_info(sc, OID_GEN_LINK_SPEED, (void *)&media_info, &len); if (linkstate == nmc_connected) ifmr->ifm_status |= IFM_ACTIVE; switch(media_info) { case 100000: ifmr->ifm_active |= IFM_10_T; break; case 1000000: ifmr->ifm_active |= IFM_100_TX; break; case 10000000: ifmr->ifm_active |= IFM_1000_T; break; default: device_printf(sc->ndis_dev, "unknown speed: %d\n", media_info); break; } return; } static void ndis_setstate_80211(sc) struct ndis_softc *sc; { struct ieee80211com *ic; ndis_80211_ssid ssid; ndis_80211_config config; ndis_80211_wep wep; int i, rval = 0, len; uint32_t arg; struct ifnet *ifp; ic = &sc->ic; ifp = &sc->ic.ic_ac.ac_if; if (!(ifp->if_flags & IFF_UP)) return; /* Set network infrastructure mode. */ len = sizeof(arg); if (ic->ic_opmode == IEEE80211_M_IBSS) arg = NDIS_80211_NET_INFRA_IBSS; else arg = NDIS_80211_NET_INFRA_BSS; rval = ndis_set_info(sc, OID_802_11_INFRASTRUCTURE_MODE, &arg, &len); if (rval) device_printf (sc->ndis_dev, "set infra failed: %d\n", rval); /* Set WEP */ #ifdef IEEE80211_F_WEPON if (ic->ic_flags & IEEE80211_F_WEPON) { #else if (ic->ic_wep_mode >= IEEE80211_WEP_ON) { #endif for (i = 0; i < IEEE80211_WEP_NKID; i++) { if (ic->ic_nw_keys[i].wk_len) { bzero((char *)&wep, sizeof(wep)); wep.nw_keylen = ic->ic_nw_keys[i].wk_len; #ifdef notdef /* 5 and 13 are the only valid key lengths */ if (ic->ic_nw_keys[i].wk_len < 5) wep.nw_keylen = 5; else if (ic->ic_nw_keys[i].wk_len > 5 && ic->ic_nw_keys[i].wk_len < 13) wep.nw_keylen = 13; #endif wep.nw_keyidx = i; wep.nw_length = (sizeof(uint32_t) * 3) + wep.nw_keylen; if (i == ic->ic_wep_txkey) wep.nw_keyidx |= NDIS_80211_WEPKEY_TX; bcopy(ic->ic_nw_keys[i].wk_key, wep.nw_keydata, wep.nw_length); len = sizeof(wep); rval = ndis_set_info(sc, OID_802_11_ADD_WEP, &wep, &len); if (rval) device_printf(sc->ndis_dev, "set wepkey failed: %d\n", rval); } } arg = NDIS_80211_WEPSTAT_ENABLED; len = sizeof(arg); rval = ndis_set_info(sc, OID_802_11_WEP_STATUS, &arg, &len); if (rval) device_printf(sc->ndis_dev, "enable WEP failed: %d\n", rval); #ifndef IEEE80211_F_WEPON if (ic->ic_wep_mode != IEEE80211_WEP_8021X && ic->ic_wep_mode != IEEE80211_WEP_ON) arg = NDIS_80211_PRIVFILT_ACCEPTALL; else #endif arg = NDIS_80211_PRIVFILT_8021XWEP; len = sizeof(arg); rval = ndis_set_info(sc, OID_802_11_PRIVACY_FILTER, &arg, &len); #ifdef IEEE80211_WEP_8021X /*IEEE80211_F_WEPON*/ /* Accept that we only have "shared" and 802.1x modes. */ if (rval == 0) { if (arg == NDIS_80211_PRIVFILT_ACCEPTALL) ic->ic_wep_mode = IEEE80211_WEP_MIXED; else ic->ic_wep_mode = IEEE80211_WEP_8021X; } #endif arg = NDIS_80211_AUTHMODE_AUTO; } else { arg = NDIS_80211_WEPSTAT_DISABLED; len = sizeof(arg); ndis_set_info(sc, OID_802_11_WEP_STATUS, &arg, &len); arg = NDIS_80211_AUTHMODE_OPEN; } len = sizeof(arg); rval = ndis_set_info(sc, OID_802_11_AUTHENTICATION_MODE, &arg, &len); #ifdef notyet if (rval) device_printf (sc->ndis_dev, "set auth failed: %d\n", rval); #endif /* Set SSID. */ len = sizeof(ssid); bzero((char *)&ssid, len); ssid.ns_ssidlen = ic->ic_des_esslen; if (ssid.ns_ssidlen == 0) { ssid.ns_ssidlen = 1; } else bcopy(ic->ic_des_essid, ssid.ns_ssid, ssid.ns_ssidlen); rval = ndis_set_info(sc, OID_802_11_SSID, &ssid, &len); if (rval) device_printf (sc->ndis_dev, "set ssid failed: %d\n", rval); len = sizeof(config); + bzero((char *)&config, len); + config.nc_length = len; + config.nc_fhconfig.ncf_length = sizeof(ndis_80211_config_fh); rval = ndis_get_info(sc, OID_802_11_CONFIGURATION, &config, &len); if (rval == 0) { int chan; chan = ieee80211_chan2ieee(ic, ic->ic_bss->ni_chan); if (chan != ieee80211_mhz2ieee(config.nc_dsconfig / 1000, 0)) { config.nc_dsconfig = ic->ic_bss->ni_chan->ic_freq * 1000; + len = sizeof(config); + config.nc_length = len; + config.nc_fhconfig.ncf_length = + sizeof(ndis_80211_config_fh); rval = ndis_set_info(sc, OID_802_11_CONFIGURATION, &config, &len); if (rval) device_printf(sc->ndis_dev, "couldn't change " "DS config to %ukHz: %d\n", config.nc_dsconfig, rval); } } else device_printf(sc->ndis_dev, "couldn't retrieve " "channel info: %d\n", rval); return; } static void ndis_media_status(struct ifnet *ifp, struct ifmediareq *imr) { struct ieee80211com *ic = (void *)ifp; struct ieee80211_node *ni = NULL; imr->ifm_status = IFM_AVALID; imr->ifm_active = IFM_IEEE80211; if (ic->ic_state == IEEE80211_S_RUN) imr->ifm_status |= IFM_ACTIVE; imr->ifm_active |= IFM_AUTO; switch (ic->ic_opmode) { case IEEE80211_M_STA: ni = ic->ic_bss; /* calculate rate subtype */ imr->ifm_active |= ieee80211_rate2media(ic, ni->ni_rates.rs_rates[ni->ni_txrate], ic->ic_curmode); break; case IEEE80211_M_IBSS: ni = ic->ic_bss; /* calculate rate subtype */ imr->ifm_active |= ieee80211_rate2media(ic, ni->ni_rates.rs_rates[ni->ni_txrate], ic->ic_curmode); imr->ifm_active |= IFM_IEEE80211_ADHOC; break; case IEEE80211_M_AHDEMO: /* should not come here */ break; case IEEE80211_M_HOSTAP: imr->ifm_active |= IFM_IEEE80211_HOSTAP; break; case IEEE80211_M_MONITOR: imr->ifm_active |= IFM_IEEE80211_MONITOR; break; } switch (ic->ic_curmode) { case IEEE80211_MODE_11A: imr->ifm_active |= IFM_MAKEMODE(IFM_IEEE80211_11A); break; case IEEE80211_MODE_11B: imr->ifm_active |= IFM_MAKEMODE(IFM_IEEE80211_11B); break; case IEEE80211_MODE_11G: imr->ifm_active |= IFM_MAKEMODE(IFM_IEEE80211_11G); break; case IEEE80211_MODE_TURBO: imr->ifm_active |= IFM_MAKEMODE(IFM_IEEE80211_11A) | IFM_IEEE80211_TURBO; break; } } static int ndis_get_assoc(sc, assoc) struct ndis_softc *sc; ndis_wlan_bssid_ex *assoc; { ndis_80211_bssid_list_ex *bl; ndis_wlan_bssid_ex *bs; ndis_80211_macaddr bssid; int i, len, error; if (!sc->ndis_link) return(ENOENT); len = sizeof(bssid); error = ndis_get_info(sc, OID_802_11_BSSID, &bssid, &len); if (error) { device_printf(sc->ndis_dev, "failed to get bssid\n"); return(ENOENT); } len = 0; error = ndis_get_info(sc, OID_802_11_BSSID_LIST, NULL, &len); if (error != ENOSPC) { device_printf(sc->ndis_dev, "bssid_list failed\n"); return (error); } bl = malloc(len, M_TEMP, M_NOWAIT|M_ZERO); error = ndis_get_info(sc, OID_802_11_BSSID_LIST, bl, &len); if (error) { free(bl, M_TEMP); device_printf(sc->ndis_dev, "bssid_list failed\n"); return (error); } bs = (ndis_wlan_bssid_ex *)&bl->nblx_bssid[0]; for (i = 0; i < bl->nblx_items; i++) { if (bcmp(bs->nwbx_macaddr, bssid, sizeof(bssid)) == 0) { bcopy((char *)bs, (char *)assoc, bs->nwbx_len); free(bl, M_TEMP); return(0); } bs = (ndis_wlan_bssid_ex *)((char *)bs + bs->nwbx_len); } free(bl, M_TEMP); return(ENOENT); } static void ndis_getstate_80211(sc) struct ndis_softc *sc; { struct ieee80211com *ic; ndis_80211_ssid ssid; ndis_80211_config config; ndis_wlan_bssid_ex bs; int rval, len, i = 0; uint32_t arg; struct ifnet *ifp; ic = &sc->ic; ifp = &sc->ic.ic_ac.ac_if; if (!(ifp->if_flags & IFF_UP)) return; if (sc->ndis_link) ic->ic_state = IEEE80211_S_RUN; else ic->ic_state = IEEE80211_S_ASSOC; /* * If we're associated, retrieve info on the current bssid. */ - if (ndis_get_assoc(sc, &bs) == 0) { + if ((rval = ndis_get_assoc(sc, &bs)) == 0) { switch(bs.nwbx_nettype) { case NDIS_80211_NETTYPE_11FH: case NDIS_80211_NETTYPE_11DS: ic->ic_curmode = IEEE80211_MODE_11B; break; case NDIS_80211_NETTYPE_11OFDM5: ic->ic_curmode = IEEE80211_MODE_11A; break; case NDIS_80211_NETTYPE_11OFDM24: ic->ic_curmode = IEEE80211_MODE_11G; break; default: device_printf(sc->ndis_dev, "unknown nettype %d\n", arg); break; } - } + } else + return; len = sizeof(ssid); bzero((char *)&ssid, len); rval = ndis_get_info(sc, OID_802_11_SSID, &ssid, &len); if (rval) device_printf (sc->ndis_dev, "get ssid failed: %d\n", rval); bcopy(ssid.ns_ssid, ic->ic_bss->ni_essid, ssid.ns_ssidlen); ic->ic_bss->ni_esslen = ssid.ns_ssidlen; len = sizeof(arg); rval = ndis_get_info(sc, OID_GEN_LINK_SPEED, &arg, &len); + if (rval) + device_printf (sc->ndis_dev, "get link speed failed: %d\n", + rval); if (ic->ic_modecaps & (1<ic_bss->ni_rates = ic->ic_sup_rates[IEEE80211_MODE_11B]; for (i = 0; i < ic->ic_bss->ni_rates.rs_nrates; i++) { if ((ic->ic_bss->ni_rates.rs_rates[i] & IEEE80211_RATE_VAL) == arg / 5000) break; } } if (i == ic->ic_bss->ni_rates.rs_nrates && ic->ic_modecaps & (1<ic_bss->ni_rates = ic->ic_sup_rates[IEEE80211_MODE_11G]; for (i = 0; i < ic->ic_bss->ni_rates.rs_nrates; i++) { if ((ic->ic_bss->ni_rates.rs_rates[i] & IEEE80211_RATE_VAL) == arg / 5000) break; } } if (i == ic->ic_bss->ni_rates.rs_nrates) device_printf(sc->ndis_dev, "no matching rate for: %d\n", arg / 5000); else ic->ic_bss->ni_txrate = i; if (ic->ic_caps & IEEE80211_C_PMGT) { len = sizeof(arg); rval = ndis_get_info(sc, OID_802_11_POWER_MODE, &arg, &len); if (rval) device_printf(sc->ndis_dev, "get power mode failed: %d\n", rval); if (arg == NDIS_80211_POWERMODE_CAM) ic->ic_flags &= ~IEEE80211_F_PMGTON; else ic->ic_flags |= IEEE80211_F_PMGTON; } len = sizeof(config); + bzero((char *)&config, len); + config.nc_length = len; + config.nc_fhconfig.ncf_length = sizeof(ndis_80211_config_fh); rval = ndis_get_info(sc, OID_802_11_CONFIGURATION, &config, &len); if (rval == 0) { int chan; chan = ieee80211_mhz2ieee(config.nc_dsconfig / 1000, 0); if (chan < 0 || chan >= IEEE80211_CHAN_MAX) { if (ifp->if_flags & IFF_DEBUG) device_printf(sc->ndis_dev, "current channel " "(%uMHz) out of bounds\n", config.nc_dsconfig / 1000); ic->ic_bss->ni_chan = &ic->ic_channels[1]; } else ic->ic_bss->ni_chan = &ic->ic_channels[chan]; } else device_printf(sc->ndis_dev, "couldn't retrieve " "channel info: %d\n", rval); /* len = sizeof(arg); rval = ndis_get_info(sc, OID_802_11_WEP_STATUS, &arg, &len); if (rval) device_printf (sc->ndis_dev, "get wep status failed: %d\n", rval); if (arg == NDIS_80211_WEPSTAT_ENABLED) ic->ic_flags |= IEEE80211_F_WEPON; else ic->ic_flags &= ~IEEE80211_F_WEPON; */ return; } static int ndis_ioctl(ifp, command, data) struct ifnet *ifp; u_long command; caddr_t data; { struct ndis_softc *sc = ifp->if_softc; struct ifreq *ifr = (struct ifreq *) data; int i, error = 0; /*NDIS_LOCK(sc);*/ switch(command) { case SIOCSIFFLAGS: if (ifp->if_flags & IFF_UP) { if (ifp->if_flags & IFF_RUNNING && ifp->if_flags & IFF_PROMISC && !(sc->ndis_if_flags & IFF_PROMISC)) { sc->ndis_filter |= NDIS_PACKET_TYPE_PROMISCUOUS; i = sizeof(sc->ndis_filter); error = ndis_set_info(sc, OID_GEN_CURRENT_PACKET_FILTER, &sc->ndis_filter, &i); } else if (ifp->if_flags & IFF_RUNNING && !(ifp->if_flags & IFF_PROMISC) && sc->ndis_if_flags & IFF_PROMISC) { sc->ndis_filter &= ~NDIS_PACKET_TYPE_PROMISCUOUS; i = sizeof(sc->ndis_filter); error = ndis_set_info(sc, OID_GEN_CURRENT_PACKET_FILTER, &sc->ndis_filter, &i); } else ndis_init(sc); } else { if (ifp->if_flags & IFF_RUNNING) ndis_stop(sc); } sc->ndis_if_flags = ifp->if_flags; error = 0; break; case SIOCADDMULTI: case SIOCDELMULTI: ndis_setmulti(sc); error = 0; break; case SIOCGIFMEDIA: case SIOCSIFMEDIA: if (sc->ndis_80211) { error = ieee80211_ioctl(ifp, command, data); if (error == ENETRESET) { ndis_setstate_80211(sc); /*ndis_init(sc);*/ error = 0; } } else error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, command); break; case SIOCSIFCAP: ifp->if_capenable = ifr->ifr_reqcap; if (ifp->if_capenable & IFCAP_TXCSUM) ifp->if_hwassist = sc->ndis_hwassist; else ifp->if_hwassist = 0; ndis_set_offload(sc); break; case SIOCGIFGENERIC: case SIOCSIFGENERIC: if (sc->ndis_80211 && ifp->if_flags & IFF_UP) { if (command == SIOCGIFGENERIC) error = ndis_wi_ioctl_get(ifp, command, data); else error = ndis_wi_ioctl_set(ifp, command, data); } else error = ENOTTY; if (error != ENOTTY) break; default: sc->ndis_skip = 1; if (sc->ndis_80211) { error = ieee80211_ioctl(ifp, command, data); if (error == ENETRESET) { ndis_setstate_80211(sc); error = 0; } } else error = ether_ioctl(ifp, command, data); sc->ndis_skip = 0; break; } /*NDIS_UNLOCK(sc);*/ return(error); } static int ndis_wi_ioctl_get(ifp, command, data) struct ifnet *ifp; u_long command; caddr_t data; { struct wi_req wreq; struct ifreq *ifr; struct ndis_softc *sc; ndis_80211_bssid_list_ex *bl; ndis_wlan_bssid_ex *wb; struct wi_apinfo *api; int error, i, j, len, maxaps; sc = ifp->if_softc; ifr = (struct ifreq *)data; error = copyin(ifr->ifr_data, &wreq, sizeof(wreq)); if (error) return (error); switch (wreq.wi_type) { case WI_RID_READ_APS: len = 0; error = ndis_set_info(sc, OID_802_11_BSSID_LIST_SCAN, NULL, &len); if (error == 0) tsleep(&error, PPAUSE|PCATCH, "ssidscan", hz * 2); len = 0; error = ndis_get_info(sc, OID_802_11_BSSID_LIST, NULL, &len); if (error != ENOSPC) break; bl = malloc(len, M_DEVBUF, M_WAITOK|M_ZERO); error = ndis_get_info(sc, OID_802_11_BSSID_LIST, bl, &len); if (error) { free(bl, M_DEVBUF); break; } maxaps = (2 * wreq.wi_len - sizeof(int)) / sizeof(*api); maxaps = MIN(maxaps, bl->nblx_items); wreq.wi_len = (maxaps * sizeof(*api) + sizeof(int)) / 2; *(int *)&wreq.wi_val = maxaps; api = (struct wi_apinfo *)&((int *)&wreq.wi_val)[1]; wb = bl->nblx_bssid; while (maxaps--) { bzero(api, sizeof(*api)); bcopy(&wb->nwbx_macaddr, &api->bssid, sizeof(api->bssid)); api->namelen = wb->nwbx_ssid.ns_ssidlen; bcopy(&wb->nwbx_ssid.ns_ssid, &api->name, api->namelen); if (wb->nwbx_privacy) api->capinfo |= IEEE80211_CAPINFO_PRIVACY; /* XXX Where can we get noise information? */ api->signal = wb->nwbx_rssi + 149; /* XXX */ api->quality = api->signal; api->channel = ieee80211_mhz2ieee(wb->nwbx_config.nc_dsconfig / 1000, 0); /* In "auto" infrastructure mode, this is useless. */ if (wb->nwbx_netinfra == NDIS_80211_NET_INFRA_IBSS) api->capinfo |= IEEE80211_CAPINFO_IBSS; if (wb->nwbx_len > sizeof(ndis_wlan_bssid)) { j = sizeof(ndis_80211_rates_ex); /* handle other extended things */ } else j = sizeof(ndis_80211_rates); for (i = api->rate = 0; i < j; i++) api->rate = MAX(api->rate, 5 * (wb->nwbx_supportedrates[i] & 0x7f)); api++; wb = (ndis_wlan_bssid_ex *)((char *)wb + wb->nwbx_len); } free(bl, M_DEVBUF); error = copyout(&wreq, ifr->ifr_data, sizeof(wreq)); break; default: error = ENOTTY; break; } return (error); } static int ndis_wi_ioctl_set(ifp, command, data) struct ifnet *ifp; u_long command; caddr_t data; { struct wi_req wreq; struct ifreq *ifr; struct ndis_softc *sc; uint32_t foo; int error, len; error = suser(curthread); if (error) return (error); sc = ifp->if_softc; ifr = (struct ifreq *)data; error = copyin(ifr->ifr_data, &wreq, sizeof(wreq)); if (error) return (error); switch (wreq.wi_type) { case WI_RID_SCAN_APS: case WI_RID_SCAN_REQ: /* arguments ignored */ len = sizeof(foo); foo = 0; error = ndis_set_info(sc, OID_802_11_BSSID_LIST_SCAN, &foo, &len); break; default: error = ENOTTY; break; } return (error); } static void ndis_watchdog(ifp) struct ifnet *ifp; { struct ndis_softc *sc; sc = ifp->if_softc; NDIS_LOCK(sc); ifp->if_oerrors++; device_printf(sc->ndis_dev, "watchdog timeout\n"); NDIS_UNLOCK(sc); ndis_reset_nic(sc); ndis_sched(ndis_starttask, ifp, NDIS_TASKQUEUE); return; } /* * Stop the adapter and free any mbufs allocated to the * RX and TX lists. */ static void ndis_stop(sc) struct ndis_softc *sc; { struct ifnet *ifp; ifp = &sc->arpcom.ac_if; untimeout(ndis_tick, sc, sc->ndis_stat_ch); ndis_halt_nic(sc); NDIS_LOCK(sc); ifp->if_timer = 0; sc->ndis_link = 0; ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); NDIS_UNLOCK(sc); return; } /* * Stop all chip I/O so that the kernel's probe routines don't * get confused by errant DMAs when rebooting. */ static void ndis_shutdown(dev) device_t dev; { struct ndis_softc *sc; sc = device_get_softc(dev); ndis_shutdown_nic(sc); return; }