1/*
2 * Copyright (c) 2003
3 * Bill Paul <wpaul@windriver.com>. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Bill Paul.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30 * THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include <sys/cdefs.h>
34__FBSDID("$FreeBSD: head/sys/compat/ndis/subr_ndis.c 125599 2004-02-08 20:39:35Z wpaul $");
35
36/*
37 * This file implements a translation layer between the BSD networking
38 * infrasturcture and Windows(R) NDIS network driver modules. A Windows
39 * NDIS driver calls into several functions in the NDIS.SYS Windows
40 * kernel module and exports a table of functions designed to be called
41 * by the NDIS subsystem. Using the PE loader, we can patch our own
42 * versions of the NDIS routines into a given Windows driver module and
43 * convince the driver that it is in fact running on Windows.
44 *
45 * We provide a table of all our implemented NDIS routines which is patched
46 * into the driver object code. All our exported routines must use the
47 * _stdcall calling convention, since that's what the Windows object code
48 * expects.
49 */
50
51
52#include <sys/param.h>
53#include <sys/types.h>
54#include <sys/errno.h>
55
56#include <sys/callout.h>
57#include <sys/kernel.h>
58#include <sys/systm.h>
59#include <sys/malloc.h>
60#include <sys/lock.h>
61#include <sys/mutex.h>
62#include <sys/socket.h>
63#include <sys/sysctl.h>
64#include <sys/timespec.h>
65#include <sys/smp.h>
66#include <sys/queue.h>
67#include <sys/proc.h>
68#include <sys/filedesc.h>
69#include <sys/namei.h>
70#include <sys/fcntl.h>
71#include <sys/vnode.h>
72#include <sys/kthread.h>
73
74#include <net/if.h>
75#include <net/if_arp.h>
76#include <net/ethernet.h>
77#include <net/if_dl.h>
78#include <net/if_media.h>
79
80#include <machine/atomic.h>
81#include <machine/bus_memio.h>
82#include <machine/bus_pio.h>
83#include <machine/bus.h>
84#include <machine/resource.h>
85
86#include <sys/bus.h>
87#include <sys/rman.h>
88
89#include <machine/stdarg.h>
90
91#include <net80211/ieee80211_var.h>
92#include <net80211/ieee80211_ioctl.h>
93
94#include <dev/pci/pcireg.h>
95#include <dev/pci/pcivar.h>
96
97#include <compat/ndis/pe_var.h>
98#include <compat/ndis/resource_var.h>
99#include <compat/ndis/ntoskrnl_var.h>
100#include <compat/ndis/ndis_var.h>
101#include <compat/ndis/cfg_var.h>
102#include <dev/if_ndis/if_ndisvar.h>
103
104#define FUNC void(*)(void)
105
106static struct mtx *ndis_interlock;
107static char ndis_filepath[MAXPATHLEN];
108struct mtx_pool *ndis_mtxpool;
109extern struct nd_head ndis_devhead;
110
111SYSCTL_STRING(_hw, OID_AUTO, ndis_filepath, CTLFLAG_RW, ndis_filepath,
112 MAXPATHLEN, "Path used by NdisOpenFile() to search for files");
113
114__stdcall static void ndis_initwrap(ndis_handle *,
115 device_object *, void *, void *);
116__stdcall static ndis_status ndis_register_miniport(ndis_handle,
117 ndis_miniport_characteristics *, int);
118__stdcall static ndis_status ndis_malloc_withtag(void **, uint32_t, uint32_t);
119__stdcall static ndis_status ndis_malloc(void **,
120 uint32_t, uint32_t, ndis_physaddr);
121__stdcall static void ndis_free(void *, uint32_t, uint32_t);
122__stdcall static ndis_status ndis_setattr_ex(ndis_handle, ndis_handle,
123 uint32_t, uint32_t, ndis_interface_type);
124__stdcall static void ndis_open_cfg(ndis_status *, ndis_handle *, ndis_handle);
125__stdcall static void ndis_open_cfgbyidx(ndis_status *, ndis_handle,
126 uint32_t, ndis_unicode_string *, ndis_handle *);
127__stdcall static void ndis_open_cfgbyname(ndis_status *, ndis_handle,
128 ndis_unicode_string *, ndis_handle *);
129static ndis_status ndis_encode_parm(ndis_miniport_block *,
130 struct sysctl_oid *, ndis_parm_type, ndis_config_parm **);
131static ndis_status ndis_decode_parm(ndis_miniport_block *,
132 ndis_config_parm *, char *);
133__stdcall static void ndis_read_cfg(ndis_status *, ndis_config_parm **,
134 ndis_handle, ndis_unicode_string *, ndis_parm_type);
135__stdcall static void ndis_write_cfg(ndis_status *, ndis_handle,
136 ndis_unicode_string *, ndis_config_parm *);
137__stdcall static void ndis_close_cfg(ndis_handle);
138__stdcall static void ndis_create_lock(ndis_spin_lock *);
139__stdcall static void ndis_destroy_lock(ndis_spin_lock *);
140__stdcall static void ndis_lock(ndis_spin_lock *);
141__stdcall static void ndis_unlock(ndis_spin_lock *);
142__stdcall static uint32_t ndis_read_pci(ndis_handle, uint32_t,
143 uint32_t, void *, uint32_t);
144__stdcall static uint32_t ndis_write_pci(ndis_handle, uint32_t,
145 uint32_t, void *, uint32_t);
146static void ndis_syslog(ndis_handle, ndis_error_code, uint32_t, ...);
147static void ndis_map_cb(void *, bus_dma_segment_t *, int, int);
148__stdcall static void ndis_vtophys_load(ndis_handle, ndis_buffer *,
149 uint32_t, uint8_t, ndis_paddr_unit *, uint32_t *);
150__stdcall static void ndis_vtophys_unload(ndis_handle, ndis_buffer *, uint32_t);
151__stdcall static void ndis_create_timer(ndis_miniport_timer *, ndis_handle *,
152 ndis_timer_function, void *);
153__stdcall static void ndis_init_timer(ndis_timer *,
154 ndis_timer_function, void *);
155static void ndis_timercall(void *);
156__stdcall static void ndis_set_timer(ndis_miniport_timer *, uint32_t);
157static void ndis_tick(void *);
158__stdcall static void ndis_set_periodic_timer(ndis_miniport_timer *, uint32_t);
159__stdcall static void ndis_cancel_timer(ndis_miniport_timer *, uint8_t *);
160__stdcall static void ndis_query_resources(ndis_status *, ndis_handle,
161 ndis_resource_list *, uint32_t *);
162__stdcall static ndis_status ndis_register_ioport(void **,
163 ndis_handle, uint32_t, uint32_t);
164__stdcall static void ndis_deregister_ioport(ndis_handle,
165 uint32_t, uint32_t, void *);
166__stdcall static void ndis_read_netaddr(ndis_status *, void **,
167 uint32_t *, ndis_handle);
168__stdcall static ndis_status ndis_mapreg_cnt(uint32_t, uint32_t *);
169__stdcall static ndis_status ndis_alloc_mapreg(ndis_handle,
170 uint32_t, uint8_t, uint32_t, uint32_t);
171__stdcall static void ndis_free_mapreg(ndis_handle);
172static void ndis_mapshared_cb(void *, bus_dma_segment_t *, int, int);
173__stdcall static void ndis_alloc_sharedmem(ndis_handle, uint32_t,
174 uint8_t, void **, ndis_physaddr *);
175static void ndis_asyncmem_complete(void *);
176__stdcall static ndis_status ndis_alloc_sharedmem_async(ndis_handle,
177 uint32_t, uint8_t, void *);
178__stdcall static void ndis_free_sharedmem(ndis_handle, uint32_t,
179 uint8_t, void *, ndis_physaddr);
180__stdcall static ndis_status ndis_map_iospace(void **, ndis_handle,
181 ndis_physaddr, uint32_t);
182__stdcall static void ndis_unmap_iospace(ndis_handle, void *, uint32_t);
183__stdcall static uint32_t ndis_cachefill(void);
184__stdcall static uint32_t ndis_dma_align(ndis_handle);
185__stdcall static ndis_status ndis_init_sc_dma(ndis_handle,
186 uint8_t, uint32_t);
187__stdcall static void ndis_alloc_packetpool(ndis_status *,
188 ndis_handle *, uint32_t, uint32_t);
189__stdcall static void ndis_ex_alloc_packetpool(ndis_status *,
190 ndis_handle *, uint32_t, uint32_t, uint32_t);
191__stdcall static uint32_t ndis_packetpool_use(ndis_handle);
192__stdcall static void ndis_free_packetpool(ndis_handle);
193__stdcall static void ndis_alloc_packet(ndis_status *,
194 ndis_packet **, ndis_handle);
195__stdcall static void ndis_release_packet(ndis_packet *);
196__stdcall static void ndis_unchain_headbuf(ndis_packet *, ndis_buffer **);
197__stdcall static void ndis_unchain_tailbuf(ndis_packet *, ndis_buffer **);
198__stdcall static void ndis_alloc_bufpool(ndis_status *,
199 ndis_handle *, uint32_t);
200__stdcall static void ndis_free_bufpool(ndis_handle);
201__stdcall static void ndis_alloc_buf(ndis_status *, ndis_buffer **,
202 ndis_handle, void *, uint32_t);
203__stdcall static void ndis_release_buf(ndis_buffer *);
204__stdcall static uint32_t ndis_buflen(ndis_buffer *);
205__stdcall static void ndis_query_buf(ndis_buffer *, void **, uint32_t *);
206__stdcall static void ndis_query_buf_safe(ndis_buffer *, void **,
207 uint32_t *, uint32_t);
208__stdcall static void *ndis_buf_vaddr(ndis_buffer *);
209__stdcall static void *ndis_buf_vaddr_safe(ndis_buffer *, uint32_t);
210__stdcall static void ndis_adjust_buflen(ndis_buffer *, int);
211__stdcall static uint32_t ndis_interlock_inc(uint32_t *);
212__stdcall static uint32_t ndis_interlock_dec(uint32_t *);
213__stdcall static void ndis_init_event(ndis_event *);
214__stdcall static void ndis_set_event(ndis_event *);
215__stdcall static void ndis_reset_event(ndis_event *);
216__stdcall static uint8_t ndis_wait_event(ndis_event *, uint32_t);
217__stdcall static ndis_status ndis_unicode2ansi(ndis_ansi_string *,
218 ndis_unicode_string *);
219__stdcall static ndis_status ndis_ansi2unicode(ndis_unicode_string *,
220 ndis_ansi_string *);
221__stdcall static ndis_status ndis_assign_pcirsrc(ndis_handle,
222 uint32_t, ndis_resource_list **);
223__stdcall static ndis_status ndis_register_intr(ndis_miniport_interrupt *,
224 ndis_handle, uint32_t, uint32_t, uint8_t,
225 uint8_t, ndis_interrupt_mode);
226__stdcall static void ndis_deregister_intr(ndis_miniport_interrupt *);
227__stdcall static void ndis_register_shutdown(ndis_handle, void *,
228 ndis_shutdown_handler);
229__stdcall static void ndis_deregister_shutdown(ndis_handle);
230__stdcall static uint32_t ndis_numpages(ndis_buffer *);
231__stdcall static void ndis_buf_physpages(ndis_buffer *, uint32_t *);
232__stdcall static void ndis_query_bufoffset(ndis_buffer *,
233 uint32_t *, uint32_t *);
234__stdcall static void ndis_sleep(uint32_t);
235__stdcall static uint32_t ndis_read_pccard_amem(ndis_handle,
236 uint32_t, void *, uint32_t);
237__stdcall static uint32_t ndis_write_pccard_amem(ndis_handle,
238 uint32_t, void *, uint32_t);
239__stdcall static list_entry *ndis_insert_head(list_entry *,
240 list_entry *, ndis_spin_lock *);
241__stdcall static list_entry *ndis_remove_head(list_entry *,
242 ndis_spin_lock *);
243__stdcall static list_entry *ndis_insert_tail(list_entry *,
244 list_entry *, ndis_spin_lock *);
245__stdcall static uint8_t ndis_sync_with_intr(ndis_miniport_interrupt *,
246 void *, void *);
247__stdcall static void ndis_time(uint64_t *);
248__stdcall static void ndis_uptime(uint32_t *);
249__stdcall static void ndis_init_string(ndis_unicode_string *, char *);
250__stdcall static void ndis_init_ansi_string(ndis_ansi_string *, char *);
251__stdcall static void ndis_init_unicode_string(ndis_unicode_string *,
252 uint16_t *);
253__stdcall static void ndis_free_string(ndis_unicode_string *);
254__stdcall static ndis_status ndis_remove_miniport(ndis_handle *);
255__stdcall static void ndis_termwrap(ndis_handle, void *);
256__stdcall static void ndis_get_devprop(ndis_handle, device_object **,
257 device_object **, device_object **, cm_resource_list *,
258 cm_resource_list *);
259__stdcall static void ndis_firstbuf(ndis_packet *, ndis_buffer **,
260 void **, uint32_t *, uint32_t *);
261__stdcall static void ndis_firstbuf_safe(ndis_packet *, ndis_buffer **,
262 void **, uint32_t *, uint32_t *, uint32_t);
263__stdcall static void ndis_open_file(ndis_status *, ndis_handle *, uint32_t *,
264 ndis_unicode_string *, ndis_physaddr);
265__stdcall static void ndis_map_file(ndis_status *, void **, ndis_handle);
266__stdcall static void ndis_unmap_file(ndis_handle);
267__stdcall static void ndis_close_file(ndis_handle);
268__stdcall static u_int8_t ndis_cpu_cnt(void);
269__stdcall static void ndis_ind_statusdone(ndis_handle);
270__stdcall static void ndis_ind_status(ndis_handle, ndis_status,
271 void *, uint32_t);
272static void ndis_workfunc(void *);
273__stdcall static ndis_status ndis_sched_workitem(ndis_work_item *);
274__stdcall static void ndis_pkt_to_pkt(ndis_packet *, uint32_t, uint32_t,
275 ndis_packet *, uint32_t, uint32_t *);
276__stdcall static void ndis_pkt_to_pkt_safe(ndis_packet *, uint32_t, uint32_t,
277 ndis_packet *, uint32_t, uint32_t *, uint32_t);
278__stdcall static ndis_status ndis_register_dev(ndis_handle,
279 ndis_unicode_string *, ndis_unicode_string *, driver_dispatch **,
280 void **, ndis_handle *);
281__stdcall static ndis_status ndis_deregister_dev(ndis_handle);
282__stdcall static ndis_status ndis_query_name(ndis_unicode_string *,
283 ndis_handle);
284__stdcall static void ndis_register_unload(ndis_handle, void *);
285__stdcall static void dummy(void);
286
287/*
288 * Some really old drivers do not properly check the return value
289 * from NdisAllocatePacket() and NdisAllocateBuffer() and will
290 * sometimes allocate few more buffers/packets that they originally
291 * requested when they created the pool. To prevent this from being
292 * a problem, we allocate a few extra buffers/packets beyond what
293 * the driver asks for. This #define controls how many.
294 */
295#define NDIS_POOL_EXTRA 16
296
297int
298ndis_libinit()
299{
300 strcpy(ndis_filepath, "/compat/ndis");
301 ndis_mtxpool = mtx_pool_create("ndis mutex pool",
302 1024, MTX_DEF | MTX_RECURSE | MTX_DUPOK);;
303 ndis_interlock = mtx_pool_alloc(ndis_mtxpool);
304 return(0);
305}
306
307int
308ndis_libfini()
309{
310 mtx_pool_destroy(&ndis_mtxpool);
311 return(0);
312}
313
314/*
315 * NDIS deals with strings in unicode format, so we have
316 * do deal with them that way too. For now, we only handle
317 * conversion between unicode and ASCII since that's all
318 * that device drivers care about.
319 */
320
321int
322ndis_ascii_to_unicode(ascii, unicode)
323 char *ascii;
324 uint16_t **unicode;
325{
326 uint16_t *ustr;
327 int i;
328
329 if (*unicode == NULL)
330 *unicode = malloc(strlen(ascii) * 2, M_DEVBUF, M_WAITOK);
331
332 if (*unicode == NULL)
333 return(ENOMEM);
334 ustr = *unicode;
335 for (i = 0; i < strlen(ascii); i++) {
336 *ustr = (uint16_t)ascii[i];
337 ustr++;
338 }
339
340 return(0);
341}
342
343int
344ndis_unicode_to_ascii(unicode, ulen, ascii)
345 uint16_t *unicode;
346 int ulen;
347 char **ascii;
348{
349 uint8_t *astr;
350 int i;
351
352 if (*ascii == NULL)
353 *ascii = malloc((ulen / 2) + 1, M_DEVBUF, M_WAITOK|M_ZERO);
354 if (*ascii == NULL)
355 return(ENOMEM);
356 astr = *ascii;
357 for (i = 0; i < ulen / 2; i++) {
358 *astr = (uint8_t)unicode[i];
359 astr++;
360 }
361
362 return(0);
363}
364
365__stdcall static void
366ndis_initwrap(wrapper, drv_obj, path, unused)
367 ndis_handle *wrapper;
368 device_object *drv_obj;
369 void *path;
370 void *unused;
371{
372 ndis_miniport_block *block;
373
374 block = drv_obj->do_rsvd;
375 *wrapper = block;
376
377 return;
378}
379
380__stdcall static void
381ndis_termwrap(handle, syspec)
382 ndis_handle handle;
383 void *syspec;
384{
385 return;
386}
387
388__stdcall static ndis_status
389ndis_register_miniport(handle, characteristics, len)
390 ndis_handle handle;
391 ndis_miniport_characteristics *characteristics;
392 int len;
393{
394 ndis_miniport_block *block;
395 struct ndis_softc *sc;
396
397 block = (ndis_miniport_block *)handle;
398 sc = (struct ndis_softc *)block->nmb_ifp;
399 bcopy((char *)characteristics, (char *)&sc->ndis_chars,
400 sizeof(ndis_miniport_characteristics));
401 if (sc->ndis_chars.nmc_version_major < 5 ||
402 sc->ndis_chars.nmc_version_minor < 1) {
403 sc->ndis_chars.nmc_shutdown_handler = NULL;
404 sc->ndis_chars.nmc_canceltxpkts_handler = NULL;
405 sc->ndis_chars.nmc_pnpevent_handler = NULL;
406 }
407
408 return(NDIS_STATUS_SUCCESS);
409}
410
411__stdcall static ndis_status
412ndis_malloc_withtag(vaddr, len, tag)
413 void **vaddr;
414 uint32_t len;
415 uint32_t tag;
416{
417 void *mem;
418
419 mem = malloc(len, M_DEVBUF, M_NOWAIT);
420 if (mem == NULL)
421 return(NDIS_STATUS_RESOURCES);
422 *vaddr = mem;
423
424 return(NDIS_STATUS_SUCCESS);
425}
426
427__stdcall static ndis_status
428ndis_malloc(vaddr, len, flags, highaddr)
429 void **vaddr;
430 uint32_t len;
431 uint32_t flags;
432 ndis_physaddr highaddr;
433{
434 void *mem;
435
436 mem = malloc(len, M_DEVBUF, M_NOWAIT);
437 if (mem == NULL)
438 return(NDIS_STATUS_RESOURCES);
439 *vaddr = mem;
440
441 return(NDIS_STATUS_SUCCESS);
442}
443
444__stdcall static void
445ndis_free(vaddr, len, flags)
446 void *vaddr;
447 uint32_t len;
448 uint32_t flags;
449{
450 if (len == 0)
451 return;
452 free(vaddr, M_DEVBUF);
453
454 return;
455}
456
457__stdcall static ndis_status
458ndis_setattr_ex(adapter_handle, adapter_ctx, hangsecs,
459 flags, iftype)
460 ndis_handle adapter_handle;
461 ndis_handle adapter_ctx;
462 uint32_t hangsecs;
463 uint32_t flags;
464 ndis_interface_type iftype;
465{
466 ndis_miniport_block *block;
467
468 /*
469 * Save the adapter context, we need it for calling
470 * the driver's internal functions.
471 */
472 block = (ndis_miniport_block *)adapter_handle;
473 block->nmb_miniportadapterctx = adapter_ctx;
474 block->nmb_checkforhangsecs = hangsecs;
475
476 return(NDIS_STATUS_SUCCESS);
477}
478
479__stdcall static void
480ndis_open_cfg(status, cfg, wrapctx)
481 ndis_status *status;
482 ndis_handle *cfg;
483 ndis_handle wrapctx;
484{
485 *cfg = wrapctx;
486 *status = NDIS_STATUS_SUCCESS;
487 return;
488}
489
490__stdcall static void
491ndis_open_cfgbyname(status, cfg, subkey, subhandle)
492 ndis_status *status;
493 ndis_handle cfg;
494 ndis_unicode_string *subkey;
495 ndis_handle *subhandle;
496{
497 *subhandle = cfg;
498 *status = NDIS_STATUS_SUCCESS;
499 return;
500}
501
502__stdcall static void
503ndis_open_cfgbyidx(status, cfg, idx, subkey, subhandle)
504 ndis_status *status;
505 ndis_handle cfg;
506 uint32_t idx;
507 ndis_unicode_string *subkey;
508 ndis_handle *subhandle;
509{
510 *status = NDIS_STATUS_FAILURE;
511 return;
512}
513
514static ndis_status
515ndis_encode_parm(block, oid, type, parm)
516 ndis_miniport_block *block;
517 struct sysctl_oid *oid;
518 ndis_parm_type type;
519 ndis_config_parm **parm;
520{
521 uint16_t *unicode;
522 ndis_unicode_string *ustr;
523
524 unicode = (uint16_t *)&block->nmb_dummybuf;
525
526 switch(type) {
527 case ndis_parm_string:
528 ndis_ascii_to_unicode((char *)oid->oid_arg1, &unicode);
529 (*parm)->ncp_type = ndis_parm_string;
530 ustr = &(*parm)->ncp_parmdata.ncp_stringdata;
531 ustr->nus_len = strlen((char *)oid->oid_arg1) * 2;
532 ustr->nus_buf = unicode;
533 break;
534 case ndis_parm_int:
535 (*parm)->ncp_type = ndis_parm_int;
536 (*parm)->ncp_parmdata.ncp_intdata =
537 strtol((char *)oid->oid_arg1, NULL, 10);
538 break;
539 case ndis_parm_hexint:
540 (*parm)->ncp_type = ndis_parm_hexint;
541 (*parm)->ncp_parmdata.ncp_intdata =
542 strtoul((char *)oid->oid_arg1, NULL, 16);
543 break;
544 default:
545 return(NDIS_STATUS_FAILURE);
546 break;
547 }
548
549 return(NDIS_STATUS_SUCCESS);
550}
551
552__stdcall static void
553ndis_read_cfg(status, parm, cfg, key, type)
554 ndis_status *status;
555 ndis_config_parm **parm;
556 ndis_handle cfg;
557 ndis_unicode_string *key;
558 ndis_parm_type type;
559{
560 char *keystr = NULL;
561 uint16_t *unicode;
562 ndis_miniport_block *block;
563 struct ndis_softc *sc;
564 struct sysctl_oid *oidp;
565 struct sysctl_ctx_entry *e;
566
567 block = (ndis_miniport_block *)cfg;
568 sc = (struct ndis_softc *)block->nmb_ifp;
569
570 if (key->nus_len == 0 || key->nus_buf == NULL) {
571 *status = NDIS_STATUS_FAILURE;
572 return;
573 }
574
575 ndis_unicode_to_ascii(key->nus_buf, key->nus_len, &keystr);
576
577 *parm = &block->nmb_replyparm;
578 bzero((char *)&block->nmb_replyparm, sizeof(ndis_config_parm));
579 unicode = (uint16_t *)&block->nmb_dummybuf;
580
581 /*
582 * See if registry key is already in a list of known keys
583 * included with the driver.
584 */
585 TAILQ_FOREACH(e, &sc->ndis_ctx, link) {
586 oidp = e->entry;
587 if (strcmp(oidp->oid_name, keystr) == 0) {
588 if (strcmp((char *)oidp->oid_arg1, "UNSET") == 0) {
589 free(keystr, M_DEVBUF);
590 *status = NDIS_STATUS_FAILURE;
591 return;
592 }
593 *status = ndis_encode_parm(block, oidp, type, parm);
594 free(keystr, M_DEVBUF);
595 return;
596 }
597 }
598
599 /*
600 * If the key didn't match, add it to the list of dynamically
601 * created ones. Sometimes, drivers refer to registry keys
602 * that aren't documented in their .INF files. These keys
603 * are supposed to be created by some sort of utility or
604 * control panel snap-in that comes with the driver software.
605 * Sometimes it's useful to be able to manipulate these.
606 * If the driver requests the key in the form of a string,
607 * make its default value an empty string, otherwise default
608 * it to "0".
609 */
610
611 if (type == ndis_parm_int || type == ndis_parm_hexint)
612 ndis_add_sysctl(sc, keystr, "(dynamic integer key)",
613 "UNSET", CTLFLAG_RW);
614 else
615 ndis_add_sysctl(sc, keystr, "(dynamic string key)",
616 "UNSET", CTLFLAG_RW);
617
618 free(keystr, M_DEVBUF);
619 *status = NDIS_STATUS_FAILURE;
620 return;
621}
622
623static ndis_status
624ndis_decode_parm(block, parm, val)
625 ndis_miniport_block *block;
626 ndis_config_parm *parm;
627 char *val;
628{
629 ndis_unicode_string *ustr;
630 char *astr = NULL;
631
632 switch(parm->ncp_type) {
633 case ndis_parm_string:
634 ustr = &parm->ncp_parmdata.ncp_stringdata;
635 ndis_unicode_to_ascii(ustr->nus_buf, ustr->nus_len, &astr);
636 bcopy(astr, val, 254);
637 free(astr, M_DEVBUF);
638 break;
639 case ndis_parm_int:
640 sprintf(val, "%d", parm->ncp_parmdata.ncp_intdata);
641 break;
642 case ndis_parm_hexint:
643 sprintf(val, "%xu", parm->ncp_parmdata.ncp_intdata);
644 break;
645 default:
646 return(NDIS_STATUS_FAILURE);
647 break;
648 }
649 return(NDIS_STATUS_SUCCESS);
650}
651
652__stdcall static void
653ndis_write_cfg(status, cfg, key, parm)
654 ndis_status *status;
655 ndis_handle cfg;
656 ndis_unicode_string *key;
657 ndis_config_parm *parm;
658{
659 char *keystr = NULL;
660 ndis_miniport_block *block;
661 struct ndis_softc *sc;
662 struct sysctl_oid *oidp;
663 struct sysctl_ctx_entry *e;
664 char val[256];
665
666 block = (ndis_miniport_block *)cfg;
667 sc = (struct ndis_softc *)block->nmb_ifp;
668
669 ndis_unicode_to_ascii(key->nus_buf, key->nus_len, &keystr);
670
671 /* Decode the parameter into a string. */
672 bzero(val, sizeof(val));
673 *status = ndis_decode_parm(block, parm, val);
674 if (*status != NDIS_STATUS_SUCCESS) {
675 free(keystr, M_DEVBUF);
676 return;
677 }
678
679 /* See if the key already exists. */
680
681 TAILQ_FOREACH(e, &sc->ndis_ctx, link) {
682 oidp = e->entry;
683 if (strcmp(oidp->oid_name, keystr) == 0) {
684 /* Found it, set the value. */
685 strcpy((char *)oidp->oid_arg1, val);
686 free(keystr, M_DEVBUF);
687 return;
688 }
689 }
690
691 /* Not found, add a new key with the specified value. */
692 ndis_add_sysctl(sc, keystr, "(dynamically set key)",
693 val, CTLFLAG_RW);
694
695 free(keystr, M_DEVBUF);
696 *status = NDIS_STATUS_SUCCESS;
697 return;
698}
699
700__stdcall static void
701ndis_close_cfg(cfg)
702 ndis_handle cfg;
703{
704 return;
705}
706
707__stdcall static void
708ndis_create_lock(lock)
709 ndis_spin_lock *lock;
710{
711 lock->nsl_spinlock = (ndis_kspin_lock)mtx_pool_alloc(ndis_mtxpool);
712 return;
713}
714
715__stdcall static void
716ndis_destroy_lock(lock)
717 ndis_spin_lock *lock;
718{
719 /* We use a mutex pool, so this is a no-op. */
720 return;
721}
722
723__stdcall static void
724ndis_lock(lock)
725 ndis_spin_lock *lock;
726{
727 mtx_pool_lock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock);
728 return;
729}
730
731__stdcall static void
732ndis_unlock(lock)
733 ndis_spin_lock *lock;
734{
735 mtx_pool_unlock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock);
736 return;
737}
738
739__stdcall static uint32_t
740ndis_read_pci(adapter, slot, offset, buf, len)
741 ndis_handle adapter;
742 uint32_t slot;
743 uint32_t offset;
744 void *buf;
745 uint32_t len;
746{
747 ndis_miniport_block *block;
748 int i;
749 char *dest;
750
751 block = (ndis_miniport_block *)adapter;
752 dest = buf;
753 if (block == NULL || block->nmb_dev == NULL)
754 return(0);
755
756 for (i = 0; i < len; i++)
757 dest[i] = pci_read_config(block->nmb_dev, i + offset, 1);
758
759 return(len);
760}
761
762__stdcall static uint32_t
763ndis_write_pci(adapter, slot, offset, buf, len)
764 ndis_handle adapter;
765 uint32_t slot;
766 uint32_t offset;
767 void *buf;
768 uint32_t len;
769{
770 ndis_miniport_block *block;
771 int i;
772 char *dest;
773
774 block = (ndis_miniport_block *)adapter;
775 dest = buf;
776
777 if (block == NULL || block->nmb_dev == NULL)
778 return(0);
779
780 for (i = 0; i < len; i++)
781 pci_write_config(block->nmb_dev, i + offset, dest[i], 1);
782
783 return(len);
784}
785
786/*
787 * The errorlog routine uses a variable argument list, so we
788 * have to declare it this way.
789 */
790#define ERRMSGLEN 512
791static void
792ndis_syslog(ndis_handle adapter, ndis_error_code code,
793 uint32_t numerrors, ...)
794{
795 ndis_miniport_block *block;
796 va_list ap;
797 int i, error;
798 char *str = NULL, *ustr = NULL;
799 uint16_t flags;
800 char msgbuf[ERRMSGLEN];
801
802 block = (ndis_miniport_block *)adapter;
803
804 error = pe_get_message(block->nmb_img, code, &str, &i, &flags);
805 if (error == 0 && flags & MESSAGE_RESOURCE_UNICODE) {
806 ustr = msgbuf;
807 ndis_unicode_to_ascii((uint16_t *)str,
808 ((i / 2)) > (ERRMSGLEN - 1) ? ERRMSGLEN : i, &ustr);
809 str = ustr;
810 }
811 device_printf (block->nmb_dev, "NDIS ERROR: %x (%s)\n", code,
812 str == NULL ? "unknown error" : str);
813 device_printf (block->nmb_dev, "NDIS NUMERRORS: %x\n", numerrors);
814
815 va_start(ap, numerrors);
816 for (i = 0; i < numerrors; i++)
817 device_printf (block->nmb_dev, "argptr: %p\n",
818 va_arg(ap, void *));
819 va_end(ap);
820
821 return;
822}
823
824static void
825ndis_map_cb(arg, segs, nseg, error)
826 void *arg;
827 bus_dma_segment_t *segs;
828 int nseg;
829 int error;
830{
831 struct ndis_map_arg *ctx;
832 int i;
833
834 if (error)
835 return;
836
837 ctx = arg;
838
839 for (i = 0; i < nseg; i++) {
840 ctx->nma_fraglist[i].npu_physaddr.np_quad = segs[i].ds_addr;
841 ctx->nma_fraglist[i].npu_len = segs[i].ds_len;
842 }
843
844 ctx->nma_cnt = nseg;
845
846 return;
847}
848
849__stdcall static void
850ndis_vtophys_load(adapter, buf, mapreg, writedev, addrarray, arraysize)
851 ndis_handle adapter;
852 ndis_buffer *buf;
853 uint32_t mapreg;
854 uint8_t writedev;
855 ndis_paddr_unit *addrarray;
856 uint32_t *arraysize;
857{
858 ndis_miniport_block *block;
859 struct ndis_softc *sc;
860 struct ndis_map_arg nma;
861 bus_dmamap_t map;
862 int error;
863
864 if (adapter == NULL)
865 return;
866
867 block = (ndis_miniport_block *)adapter;
868 sc = (struct ndis_softc *)(block->nmb_ifp);
869
870 if (mapreg > sc->ndis_mmapcnt)
871 return;
872
873 map = sc->ndis_mmaps[mapreg];
874 nma.nma_fraglist = addrarray;
875
876 error = bus_dmamap_load(sc->ndis_mtag, map,
877 MDL_VA(buf), buf->nb_bytecount, ndis_map_cb,
878 (void *)&nma, BUS_DMA_NOWAIT);
879
880 if (error)
881 return;
882
883 bus_dmamap_sync(sc->ndis_mtag, map,
884 writedev ? BUS_DMASYNC_PREWRITE : BUS_DMASYNC_PREREAD);
885
886 *arraysize = nma.nma_cnt;
887
888 return;
889}
890
891__stdcall static void
892ndis_vtophys_unload(adapter, buf, mapreg)
893 ndis_handle adapter;
894 ndis_buffer *buf;
895 uint32_t mapreg;
896{
897 ndis_miniport_block *block;
898 struct ndis_softc *sc;
899 bus_dmamap_t map;
900
901 if (adapter == NULL)
902 return;
903
904 block = (ndis_miniport_block *)adapter;
905 sc = (struct ndis_softc *)(block->nmb_ifp);
906
907 if (mapreg > sc->ndis_mmapcnt)
908 return;
909
910 map = sc->ndis_mmaps[mapreg];
911
912 bus_dmamap_sync(sc->ndis_mtag, map,
913 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
914
915 bus_dmamap_unload(sc->ndis_mtag, map);
916
917 return;
918}
919
920/*
921 * This is an older pre-miniport timer init routine which doesn't
922 * accept a miniport context handle. The function context (ctx)
923 * is supposed to be a pointer to the adapter handle, which should
924 * have been handed to us via NdisSetAttributesEx(). We use this
925 * function context to track down the corresponding ndis_miniport_block
926 * structure. It's vital that we track down the miniport block structure,
927 * so if we can't do it, we panic. Note that we also play some games
928 * here by treating ndis_timer and ndis_miniport_timer as the same
929 * thing.
930 */
931
932__stdcall static void
933ndis_init_timer(timer, func, ctx)
934 ndis_timer *timer;
935 ndis_timer_function func;
936 void *ctx;
937{
938 struct ndis_timer_entry *ne = NULL;
939 ndis_miniport_block *block = NULL;
940
941 TAILQ_FOREACH(block, &ndis_devhead, link) {
942 if (block->nmb_miniportadapterctx == ctx)
943 break;
944 }
945
946 if (block->nmb_miniportadapterctx != ctx)
947 panic("NDIS driver timer context didn't "
948 "match any adapter contexts");
949
950 ne = malloc(sizeof(struct ndis_timer_entry), M_DEVBUF, M_NOWAIT);
951 callout_init(&ne->nte_ch, CALLOUT_MPSAFE);
952 TAILQ_INSERT_TAIL(&block->nmb_timerlist, ne, link);
953 ne->nte_timer = (ndis_miniport_timer *)timer;
954
955 INIT_LIST_HEAD((&timer->nt_timer.nk_header.dh_waitlisthead));
956 timer->nt_timer.nk_header.dh_sigstate = FALSE;
957 timer->nt_timer.nk_header.dh_type = EVENT_TYPE_NOTIFY;
958 timer->nt_timer.nk_header.dh_size = OTYPE_TIMER;
959 timer->nt_dpc.nk_sysarg1 = &ne->nte_ch;
960 timer->nt_dpc.nk_deferedfunc = (ndis_kdpc_func)func;
961 timer->nt_dpc.nk_deferredctx = ctx;
962
963 return;
964}
965
966__stdcall static void
967ndis_create_timer(timer, handle, func, ctx)
968 ndis_miniport_timer *timer;
969 ndis_handle *handle;
970 ndis_timer_function func;
971 void *ctx;
972{
973 struct ndis_timer_entry *ne = NULL;
974 ndis_miniport_block *block;
975 block = (ndis_miniport_block *)handle;
976
977 ne = malloc(sizeof(struct ndis_timer_entry), M_DEVBUF, M_NOWAIT);
978 callout_init(&ne->nte_ch, CALLOUT_MPSAFE);
979 TAILQ_INSERT_TAIL(&block->nmb_timerlist, ne, link);
980 ne->nte_timer = timer;
981
982 INIT_LIST_HEAD((&timer->nmt_ktimer.nk_header.dh_waitlisthead));
983 timer->nmt_ktimer.nk_header.dh_sigstate = FALSE;
984 timer->nmt_ktimer.nk_header.dh_type = EVENT_TYPE_NOTIFY;
985 timer->nmt_ktimer.nk_header.dh_size = OTYPE_TIMER;
986 timer->nmt_dpc.nk_sysarg1 = &ne->nte_ch;
987 timer->nmt_dpc.nk_deferedfunc = (ndis_kdpc_func)func;
988 timer->nmt_dpc.nk_deferredctx = ctx;
989
990 return;
991}
992
993/*
994 * The driver's timer callout is __stdcall function, so we need this
995 * intermediate step.
996 */
997
998static void
999ndis_timercall(arg)
1000 void *arg;
1001{
1002 ndis_miniport_timer *timer;
1003 __stdcall ndis_timer_function timerfunc;
1004
1005 timer = arg;
1006
1007 timerfunc = (ndis_timer_function)timer->nmt_dpc.nk_deferedfunc;
1008 timerfunc(NULL, timer->nmt_dpc.nk_deferredctx, NULL, NULL);
1009 ntoskrnl_wakeup(&timer->nmt_ktimer.nk_header);
1010
1011 return;
1012}
1013
1014/*
1015 * Windows specifies timeouts in milliseconds. We specify timeouts
1016 * in hz, so some conversion is required.
1017 */
1018__stdcall static void
1019ndis_set_timer(timer, msecs)
1020 ndis_miniport_timer *timer;
1021 uint32_t msecs;
1022{
1023 struct callout *ch;
1024 struct timeval tv;
1025
1026 tv.tv_sec = 0;
1027 tv.tv_usec = msecs * 1000;
1028
1029 ch = timer->nmt_dpc.nk_sysarg1;
1030 timer->nmt_dpc.nk_sysarg2 = ndis_timercall;
1031 timer->nmt_ktimer.nk_header.dh_sigstate = FALSE;
1032 callout_reset(ch, tvtohz(&tv), timer->nmt_dpc.nk_sysarg2, timer);
1033
1034 return;
1035}
1036
1037static void
1038ndis_tick(arg)
1039 void *arg;
1040{
1041 ndis_miniport_timer *timer;
1042 struct callout *ch;
1043 __stdcall ndis_timer_function timerfunc;
1044 struct timeval tv;
1045
1046 timer = arg;
1047
1048 timerfunc = (ndis_timer_function)timer->nmt_dpc.nk_deferedfunc;
1049 timerfunc(NULL, timer->nmt_dpc.nk_deferredctx, NULL, NULL);
1050 ntoskrnl_wakeup(&timer->nmt_ktimer.nk_header);
1051
1052 /* Automatically reload timer. */
1053
1054 tv.tv_sec = 0;
1055 tv.tv_usec = timer->nmt_ktimer.nk_period * 1000;
1056 ch = timer->nmt_dpc.nk_sysarg1;
1057 timer->nmt_ktimer.nk_header.dh_sigstate = FALSE;
1058 timer->nmt_dpc.nk_sysarg2 = ndis_tick;
1059 callout_reset(ch, tvtohz(&tv), timer->nmt_dpc.nk_sysarg2, timer);
1060
1061 return;
1062}
1063
1064__stdcall static void
1065ndis_set_periodic_timer(timer, msecs)
1066 ndis_miniport_timer *timer;
1067 uint32_t msecs;
1068{
1069 struct callout *ch;
1070 struct timeval tv;
1071
1072 tv.tv_sec = 0;
1073 tv.tv_usec = msecs * 1000;
1074
1075 timer->nmt_ktimer.nk_period = msecs;
1076 ch = timer->nmt_dpc.nk_sysarg1;
1077 timer->nmt_dpc.nk_sysarg2 = ndis_tick;
1078 timer->nmt_ktimer.nk_header.dh_sigstate = FALSE;
1079 callout_reset(ch, tvtohz(&tv), timer->nmt_dpc.nk_sysarg2, timer);
1080
1081 return;
1082}
1083
1084__stdcall static void
1085ndis_cancel_timer(timer, cancelled)
1086 ndis_miniport_timer *timer;
1087 uint8_t *cancelled;
1088{
1089 struct callout *ch;
1090
1091 if (timer == NULL)
1092 return;
1093 ch = timer->nmt_dpc.nk_sysarg1;
1094 if (ch == NULL)
1095 return;
1096 callout_stop(ch);
1097 *cancelled = timer->nmt_ktimer.nk_header.dh_sigstate;
1098
1099 return;
1100}
1101
1102__stdcall static void
1103ndis_query_resources(status, adapter, list, buflen)
1104 ndis_status *status;
1105 ndis_handle adapter;
1106 ndis_resource_list *list;
1107 uint32_t *buflen;
1108{
1109 ndis_miniport_block *block;
1110 struct ndis_softc *sc;
1111 int rsclen;
1112
1113 block = (ndis_miniport_block *)adapter;
1114 sc = (struct ndis_softc *)block->nmb_ifp;
1115
1116 rsclen = sizeof(ndis_resource_list) +
1117 (sizeof(cm_partial_resource_desc) * (sc->ndis_rescnt - 1));
1118 if (*buflen < rsclen) {
1119 *buflen = rsclen;
1120 *status = NDIS_STATUS_INVALID_LENGTH;
1121 return;
1122 }
1123
1124 bcopy((char *)block->nmb_rlist, (char *)list, *buflen);
1125 *status = NDIS_STATUS_SUCCESS;
1126 return;
1127}
1128
1129__stdcall static ndis_status
1130ndis_register_ioport(offset, adapter, port, numports)
1131 void **offset;
1132 ndis_handle adapter;
1133 uint32_t port;
1134 uint32_t numports;
1135{
1136 struct ndis_miniport_block *block;
1137 struct ndis_softc *sc;
1138
1139 if (adapter == NULL)
1140 return(NDIS_STATUS_FAILURE);
1141
1142 block = (ndis_miniport_block *)adapter;
1143 sc = (struct ndis_softc *)(block->nmb_ifp);
1144
1145 if (sc->ndis_res_io == NULL)
1146 return(NDIS_STATUS_FAILURE);
1147
1148 /* Don't let the device map more ports than we have. */
1149 if (rman_get_size(sc->ndis_res_io) < numports)
1150 return(NDIS_STATUS_INVALID_LENGTH);
1151
1152 *offset = (void *)rman_get_start(sc->ndis_res_io);
1153
1154 return(NDIS_STATUS_SUCCESS);
1155}
1156
1157__stdcall static void
1158ndis_deregister_ioport(adapter, port, numports, offset)
1159 ndis_handle adapter;
1160 uint32_t port;
1161 uint32_t numports;
1162 void *offset;
1163{
1164 return;
1165}
1166
1167__stdcall static void
1168ndis_read_netaddr(status, addr, addrlen, adapter)
1169 ndis_status *status;
1170 void **addr;
1171 uint32_t *addrlen;
1172 ndis_handle adapter;
1173{
1174 struct ndis_softc *sc;
1175 ndis_miniport_block *block;
1176 uint8_t empty[] = { 0, 0, 0, 0, 0, 0 };
1177
1178 block = (ndis_miniport_block *)adapter;
1179 sc = (struct ndis_softc *)block->nmb_ifp;
1180
1181 if (bcmp(sc->arpcom.ac_enaddr, empty, ETHER_ADDR_LEN) == 0)
1182 *status = NDIS_STATUS_FAILURE;
1183 else {
1184 *addr = sc->arpcom.ac_enaddr;
1185 *addrlen = ETHER_ADDR_LEN;
1186 *status = NDIS_STATUS_SUCCESS;
1187 }
1188
1189 return;
1190}
1191
1192__stdcall static ndis_status
1193ndis_mapreg_cnt(bustype, cnt)
1194 uint32_t bustype;
1195 uint32_t *cnt;
1196{
1197 *cnt = 8192;
1198 return(NDIS_STATUS_SUCCESS);
1199}
1200
1201__stdcall static ndis_status
1202ndis_alloc_mapreg(adapter, dmachannel, dmasize, physmapneeded, maxmap)
1203 ndis_handle adapter;
1204 uint32_t dmachannel;
1205 uint8_t dmasize;
1206 uint32_t physmapneeded;
1207 uint32_t maxmap;
1208{
1209 struct ndis_softc *sc;
1210 ndis_miniport_block *block;
1211 int error, i, nseg = NDIS_MAXSEG;
1212
1213 block = (ndis_miniport_block *)adapter;
1214 sc = (struct ndis_softc *)block->nmb_ifp;
1215
1216 sc->ndis_mmaps = malloc(sizeof(bus_dmamap_t) * physmapneeded,
1217 M_DEVBUF, M_NOWAIT|M_ZERO);
1218
1219 if (sc->ndis_mmaps == NULL)
1220 return(NDIS_STATUS_RESOURCES);
1221
1222 error = bus_dma_tag_create(sc->ndis_parent_tag, ETHER_ALIGN, 0,
1223 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL,
1224 NULL, maxmap * nseg, nseg, maxmap, BUS_DMA_ALLOCNOW,
1225 NULL, NULL, &sc->ndis_mtag);
1226
1227 if (error) {
1228 free(sc->ndis_mmaps, M_DEVBUF);
1229 return(NDIS_STATUS_RESOURCES);
1230 }
1231
1232 for (i = 0; i < physmapneeded; i++)
1233 bus_dmamap_create(sc->ndis_mtag, 0, &sc->ndis_mmaps[i]);
1234
1235 sc->ndis_mmapcnt = physmapneeded;
1236
1237 return(NDIS_STATUS_SUCCESS);
1238}
1239
1240__stdcall static void
1241ndis_free_mapreg(adapter)
1242 ndis_handle adapter;
1243{
1244 struct ndis_softc *sc;
1245 ndis_miniport_block *block;
1246 int i;
1247
1248 block = (ndis_miniport_block *)adapter;
1249 sc = (struct ndis_softc *)block->nmb_ifp;
1250
1251 for (i = 0; i < sc->ndis_mmapcnt; i++)
1252 bus_dmamap_destroy(sc->ndis_mtag, sc->ndis_mmaps[i]);
1253
1254 free(sc->ndis_mmaps, M_DEVBUF);
1255
1256 bus_dma_tag_destroy(sc->ndis_mtag);
1257
1258 return;
1259}
1260
1261static void
1262ndis_mapshared_cb(arg, segs, nseg, error)
1263 void *arg;
1264 bus_dma_segment_t *segs;
1265 int nseg;
1266 int error;
1267{
1268 ndis_physaddr *p;
1269
1270 if (error || nseg > 1)
1271 return;
1272
1273 p = arg;
1274
1275 p->np_quad = segs[0].ds_addr;
1276
1277 return;
1278}
1279
1280/*
1281 * This maps to bus_dmamem_alloc().
1282 */
1283__stdcall static void
1284ndis_alloc_sharedmem(adapter, len, cached, vaddr, paddr)
1285 ndis_handle adapter;
1286 uint32_t len;
1287 uint8_t cached;
1288 void **vaddr;
1289 ndis_physaddr *paddr;
1290{
1291 ndis_miniport_block *block;
1292 struct ndis_softc *sc;
1293 struct ndis_shmem *sh;
1294 int error;
1295
1296 if (adapter == NULL)
1297 return;
1298
1299 block = (ndis_miniport_block *)adapter;
1300 sc = (struct ndis_softc *)(block->nmb_ifp);
1301
1302 sh = malloc(sizeof(struct ndis_shmem), M_DEVBUF, M_NOWAIT|M_ZERO);
1303 if (sh == NULL)
1304 return;
1305
1306 error = bus_dma_tag_create(sc->ndis_parent_tag, 64,
1307 0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL,
1308 NULL, len, 1, len, BUS_DMA_ALLOCNOW, NULL, NULL,
1309 &sh->ndis_stag);
1310
1311 if (error) {
1312 free(sh, M_DEVBUF);
1313 return;
1314 }
1315
1316 error = bus_dmamem_alloc(sh->ndis_stag, vaddr,
1317 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &sh->ndis_smap);
1318
1319 if (error) {
1320 bus_dma_tag_destroy(sh->ndis_stag);
1321 free(sh, M_DEVBUF);
1322 return;
1323 }
1324
1325 error = bus_dmamap_load(sh->ndis_stag, sh->ndis_smap, *vaddr,
1326 len, ndis_mapshared_cb, (void *)paddr, BUS_DMA_NOWAIT);
1327
1328 if (error) {
1329 bus_dmamem_free(sh->ndis_stag, *vaddr, sh->ndis_smap);
1330 bus_dma_tag_destroy(sh->ndis_stag);
1331 free(sh, M_DEVBUF);
1332 return;
1333 }
1334
1335 sh->ndis_saddr = *vaddr;
1336 sh->ndis_next = sc->ndis_shlist;
1337 sc->ndis_shlist = sh;
1338
1339 return;
1340}
1341
1342struct ndis_allocwork {
1343 ndis_handle na_adapter;
1344 uint32_t na_len;
1345 uint8_t na_cached;
1346 void *na_ctx;
1347};
1348
1349static void
1350ndis_asyncmem_complete(arg)
1351 void *arg;
1352{
1353 ndis_miniport_block *block;
1354 struct ndis_softc *sc;
1355 struct ndis_allocwork *w;
1356 void *vaddr;
1357 ndis_physaddr paddr;
1358 __stdcall ndis_allocdone_handler donefunc;
1359
1360 w = arg;
1361 block = (ndis_miniport_block *)w->na_adapter;
1362 sc = (struct ndis_softc *)(block->nmb_ifp);
1363
1364 vaddr = NULL;
1365 paddr.np_quad = 0;
1366
1367 donefunc = sc->ndis_chars.nmc_allocate_complete_func;
1368 ndis_alloc_sharedmem(w->na_adapter, w->na_len,
1369 w->na_cached, &vaddr, &paddr);
1370 donefunc(w->na_adapter, vaddr, &paddr, w->na_len, w->na_ctx);
1371
1372 free(arg, M_DEVBUF);
1373
1374 return;
1375}
1376
1377__stdcall static ndis_status
1378ndis_alloc_sharedmem_async(adapter, len, cached, ctx)
1379 ndis_handle adapter;
1380 uint32_t len;
1381 uint8_t cached;
1382 void *ctx;
1383{
1384 struct ndis_allocwork *w;
1385
1386 if (adapter == NULL)
1387 return(NDIS_STATUS_FAILURE);
1388
1389 w = malloc(sizeof(struct ndis_allocwork), M_TEMP, M_NOWAIT);
1390
1391 if (w == NULL)
1392 return(NDIS_STATUS_FAILURE);
1393
1394 w->na_adapter = adapter;
1395 w->na_cached = cached;
1396 w->na_len = len;
1397 w->na_ctx = ctx;
1398
1399 /*
1400 * Pawn this work off on the SWI thread instead of the
1401 * taskqueue thread, because sometimes drivers will queue
1402 * up work items on the taskqueue thread that will block,
1403 * which would prevent the memory allocation from completing
1404 * when we need it.
1405 */
1406 ndis_sched(ndis_asyncmem_complete, w, NDIS_SWI);
1407
1408 return(NDIS_STATUS_PENDING);
1409}
1410
1411__stdcall static void
1412ndis_free_sharedmem(adapter, len, cached, vaddr, paddr)
1413 ndis_handle adapter;
1414 uint32_t len;
1415 uint8_t cached;
1416 void *vaddr;
1417 ndis_physaddr paddr;
1418{
1419 ndis_miniport_block *block;
1420 struct ndis_softc *sc;
1421 struct ndis_shmem *sh, *prev;
1422
1423 if (vaddr == NULL || adapter == NULL)
1424 return;
1425
1426 block = (ndis_miniport_block *)adapter;
1427 sc = (struct ndis_softc *)(block->nmb_ifp);
1428 sh = prev = sc->ndis_shlist;
1429
1430 while (sh) {
1431 if (sh->ndis_saddr == vaddr)
1432 break;
1433 prev = sh;
1434 sh = sh->ndis_next;
1435 }
1436
1437 bus_dmamap_unload(sh->ndis_stag, sh->ndis_smap);
1438 bus_dmamem_free(sh->ndis_stag, vaddr, sh->ndis_smap);
1439 bus_dma_tag_destroy(sh->ndis_stag);
1440
1441 if (sh == sc->ndis_shlist)
1442 sc->ndis_shlist = sh->ndis_next;
1443 else
1444 prev->ndis_next = sh->ndis_next;
1445
1446 free(sh, M_DEVBUF);
1447
1448 return;
1449}
1450
1451__stdcall static ndis_status
1452ndis_map_iospace(vaddr, adapter, paddr, len)
1453 void **vaddr;
1454 ndis_handle adapter;
1455 ndis_physaddr paddr;
1456 uint32_t len;
1457{
1458 ndis_miniport_block *block;
1459 struct ndis_softc *sc;
1460
1461 if (adapter == NULL)
1462 return(NDIS_STATUS_FAILURE);
1463
1464 block = (ndis_miniport_block *)adapter;
1465 sc = (struct ndis_softc *)(block->nmb_ifp);
1466
1467 if (sc->ndis_res_mem != NULL &&
1468 paddr.np_quad == rman_get_start(sc->ndis_res_mem))
1469 *vaddr = (void *)rman_get_virtual(sc->ndis_res_mem);
1470 else if (sc->ndis_res_altmem != NULL &&
1471 paddr.np_quad == rman_get_start(sc->ndis_res_altmem))
1472 *vaddr = (void *)rman_get_virtual(sc->ndis_res_altmem);
1473 else
1474 return(NDIS_STATUS_FAILURE);
1475
1476 return(NDIS_STATUS_SUCCESS);
1477}
1478
1479__stdcall static void
1480ndis_unmap_iospace(adapter, vaddr, len)
1481 ndis_handle adapter;
1482 void *vaddr;
1483 uint32_t len;
1484{
1485 return;
1486}
1487
1488__stdcall static uint32_t
1489ndis_cachefill(void)
1490{
1491 return(128);
1492}
1493
1494__stdcall static uint32_t
1495ndis_dma_align(handle)
1496 ndis_handle handle;
1497{
1498 return(128);
1499}
1500
1501/*
1502 * NDIS has two methods for dealing with NICs that support DMA.
1503 * One is to just pass packets to the driver and let it call
1504 * NdisMStartBufferPhysicalMapping() to map each buffer in the packet
1505 * all by itself, and the other is to let the NDIS library handle the
1506 * buffer mapping internally, and hand the driver an already populated
1507 * scatter/gather fragment list. If the driver calls
1508 * NdisMInitializeScatterGatherDma(), it wants to use the latter
1509 * method.
1510 */
1511
1512__stdcall static ndis_status
1513ndis_init_sc_dma(adapter, is64, maxphysmap)
1514 ndis_handle adapter;
1515 uint8_t is64;
1516 uint32_t maxphysmap;
1517{
1518 struct ndis_softc *sc;
1519 ndis_miniport_block *block;
1520 int error;
1521
1522 if (adapter == NULL)
1523 return(NDIS_STATUS_FAILURE);
1524 block = (ndis_miniport_block *)adapter;
1525 sc = (struct ndis_softc *)block->nmb_ifp;
1526
1527 /* Don't do this twice. */
1528 if (sc->ndis_sc == 1)
1529 return(NDIS_STATUS_SUCCESS);
1530
1531 error = bus_dma_tag_create(sc->ndis_parent_tag, ETHER_ALIGN, 0,
1532 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
1533 MCLBYTES * NDIS_MAXSEG, NDIS_MAXSEG, MCLBYTES, BUS_DMA_ALLOCNOW,
1534 NULL, NULL, &sc->ndis_ttag);
1535
1536 sc->ndis_sc = 1;
1537
1538 return(NDIS_STATUS_SUCCESS);
1539}
1540
1541__stdcall static void
1542ndis_alloc_packetpool(status, pool, descnum, protrsvdlen)
1543 ndis_status *status;
1544 ndis_handle *pool;
1545 uint32_t descnum;
1546 uint32_t protrsvdlen;
1547{
1548 ndis_packet *cur;
1549 int i;
1550
1551 *pool = malloc(sizeof(ndis_packet) *
1552 ((descnum + NDIS_POOL_EXTRA) + 1),
1553 M_DEVBUF, M_NOWAIT|M_ZERO);
1554
1555 if (pool == NULL) {
1556 *status = NDIS_STATUS_RESOURCES;
1557 return;
1558 }
1559
1560 cur = (ndis_packet *)*pool;
1561 cur->np_private.npp_flags = 0x1; /* mark the head of the list */
1562 for (i = 0; i < (descnum + NDIS_POOL_EXTRA); i++) {
1563 cur->np_private.npp_head = (ndis_handle)(cur + 1);
1564 cur++;
1565 }
1566
1567 *status = NDIS_STATUS_SUCCESS;
1568 return;
1569}
1570
1571__stdcall static void
1572ndis_ex_alloc_packetpool(status, pool, descnum, oflowdescnum, protrsvdlen)
1573 ndis_status *status;
1574 ndis_handle *pool;
1575 uint32_t descnum;
1576 uint32_t oflowdescnum;
1577 uint32_t protrsvdlen;
1578{
1579 return(ndis_alloc_packetpool(status, pool,
1580 descnum + oflowdescnum, protrsvdlen));
1581}
1582
1583__stdcall static uint32_t
1584ndis_packetpool_use(pool)
1585 ndis_handle pool;
1586{
1587 ndis_packet *head;
1588
1589 head = (ndis_packet *)pool;
1590
1591 return(head->np_private.npp_count);
1592}
1593
1594__stdcall static void
1595ndis_free_packetpool(pool)
1596 ndis_handle pool;
1597{
1598 free(pool, M_DEVBUF);
1599 return;
1600}
1601
1602__stdcall static void
1603ndis_alloc_packet(status, packet, pool)
1604 ndis_status *status;
1605 ndis_packet **packet;
1606 ndis_handle pool;
1607{
1608 ndis_packet *head, *pkt;
1609
1610 head = (ndis_packet *)pool;
1611
1612 if (head->np_private.npp_flags != 0x1) {
1613 *status = NDIS_STATUS_FAILURE;
1614 return;
1615 }
1616
1617 pkt = (ndis_packet *)head->np_private.npp_head;
1618
1619 if (pkt == NULL) {
1620 *status = NDIS_STATUS_RESOURCES;
1621 return;
1622 }
1623
1624 head->np_private.npp_head = pkt->np_private.npp_head;
1625
1626 pkt->np_private.npp_head = pkt->np_private.npp_tail = NULL;
1627 /* Save pointer to the pool. */
1628 pkt->np_private.npp_pool = head;
1629
1630 /* Set the oob offset pointer. Lots of things expect this. */
1631 pkt->np_private.npp_packetooboffset =
1632 offsetof(ndis_packet, np_oob);
1633
1634 /*
1635 * We must initialize the packet flags correctly in order
1636 * for the NDIS_SET_PACKET_MEDIA_SPECIFIC_INFO() and
1637 * NDIS_GET_PACKET_MEDIA_SPECIFIC_INFO() to work correctly.
1638 */
1639 pkt->np_private.npp_ndispktflags = NDIS_PACKET_ALLOCATED_BY_NDIS;
1640
1641 *packet = pkt;
1642
1643 head->np_private.npp_count++;
1644 *status = NDIS_STATUS_SUCCESS;
1645 return;
1646}
1647
1648__stdcall static void
1649ndis_release_packet(packet)
1650 ndis_packet *packet;
1651{
1652 ndis_packet *head;
1653
1654 if (packet == NULL || packet->np_private.npp_pool == NULL)
1655 return;
1656
1657 head = packet->np_private.npp_pool;
1658 if (head->np_private.npp_flags != 0x1)
1659 return;
1660
1661 packet->np_private.npp_head = head->np_private.npp_head;
1662 head->np_private.npp_head = (ndis_buffer *)packet;
1663 head->np_private.npp_count--;
1664
1665 return;
1666}
1667
1668__stdcall static void
1669ndis_unchain_headbuf(packet, buf)
1670 ndis_packet *packet;
1671 ndis_buffer **buf;
1672{
1673 ndis_packet_private *priv;
1674
1675 if (packet == NULL || buf == NULL)
1676 return;
1677
1678 priv = &packet->np_private;
1679
1680 priv->npp_validcounts = FALSE;
1681
1682 if (priv->npp_head == priv->npp_tail) {
1683 *buf = priv->npp_head;
1684 priv->npp_head = priv->npp_tail = NULL;
1685 } else {
1686 *buf = priv->npp_head;
1687 priv->npp_head = (*buf)->nb_next;
1688 }
1689
1690 return;
1691}
1692
1693__stdcall static void
1694ndis_unchain_tailbuf(packet, buf)
1695 ndis_packet *packet;
1696 ndis_buffer **buf;
1697{
1698 ndis_packet_private *priv;
1699 ndis_buffer *tmp;
1700
1701 if (packet == NULL || buf == NULL)
1702 return;
1703
1704 priv = &packet->np_private;
1705
1706 priv->npp_validcounts = FALSE;
1707
1708 if (priv->npp_head == priv->npp_tail) {
1709 *buf = priv->npp_head;
1710 priv->npp_head = priv->npp_tail = NULL;
1711 } else {
1712 *buf = priv->npp_tail;
1713 tmp = priv->npp_head;
1714 while (tmp->nb_next != priv->npp_tail)
1715 tmp = tmp->nb_next;
1716 priv->npp_tail = tmp;
1717 tmp->nb_next = NULL;
1718 }
1719
1720 return;
1721}
1722
1723/*
1724 * The NDIS "buffer" manipulation functions are somewhat misnamed.
1725 * They don't really allocate buffers: they allocate buffer mappings.
1726 * The idea is you reserve a chunk of DMA-able memory using
1727 * NdisMAllocateSharedMemory() and then use NdisAllocateBuffer()
1728 * to obtain the virtual address of the DMA-able region.
1729 * ndis_alloc_bufpool() is analagous to bus_dma_tag_create().
1730 */
1731
1732__stdcall static void
1733ndis_alloc_bufpool(status, pool, descnum)
1734 ndis_status *status;
1735 ndis_handle *pool;
1736 uint32_t descnum;
1737{
1738 ndis_buffer *cur;
1739 int i;
1740
1741 *pool = malloc(sizeof(ndis_buffer) *
1742 ((descnum + NDIS_POOL_EXTRA) + 1),
1743 M_DEVBUF, M_NOWAIT|M_ZERO);
1744
1745 if (pool == NULL) {
1746 *status = NDIS_STATUS_RESOURCES;
1747 return;
1748 }
1749
1750 cur = (ndis_buffer *)*pool;
1751 cur->nb_flags = 0x1; /* mark the head of the list */
1752 for (i = 0; i < (descnum + NDIS_POOL_EXTRA); i++) {
1753 cur->nb_next = cur + 1;
1754 cur++;
1755 }
1756
1757 *status = NDIS_STATUS_SUCCESS;
1758 return;
1759}
1760
1761__stdcall static void
1762ndis_free_bufpool(pool)
1763 ndis_handle pool;
1764{
1765 free(pool, M_DEVBUF);
1766 return;
1767}
1768
1769/*
1770 * This maps to a bus_dmamap_create() and bus_dmamap_load().
1771 */
1772__stdcall static void
1773ndis_alloc_buf(status, buffer, pool, vaddr, len)
1774 ndis_status *status;
1775 ndis_buffer **buffer;
1776 ndis_handle pool;
1777 void *vaddr;
1778 uint32_t len;
1779{
1780 ndis_buffer *head, *buf;
1781
1782 head = (ndis_buffer *)pool;
1783 if (head->nb_flags != 0x1) {
1784 *status = NDIS_STATUS_FAILURE;
1785 return;
1786 }
1787
1788 buf = head->nb_next;
1789
1790 if (buf == NULL) {
1791 *status = NDIS_STATUS_RESOURCES;
1792 return;
1793 }
1794
1795 head->nb_next = buf->nb_next;
1796
1797 /* Save pointer to the pool. */
1798 buf->nb_process = head;
1799
1800 MDL_INIT(buf, vaddr, len);
1801
1802 *buffer = buf;
1803
1804 *status = NDIS_STATUS_SUCCESS;
1805 return;
1806}
1807
1808__stdcall static void
1809ndis_release_buf(buf)
1810 ndis_buffer *buf;
1811{
1812 ndis_buffer *head;
1813
1814 if (buf == NULL || buf->nb_process == NULL)
1815 return;
1816
1817 head = buf->nb_process;
1818
1819 if (head->nb_flags != 0x1)
1820 return;
1821
1822 buf->nb_next = head->nb_next;
1823 head->nb_next = buf;
1824
1825 return;
1826}
1827
1828/* Aw c'mon. */
1829
1830__stdcall static uint32_t
1831ndis_buflen(buf)
1832 ndis_buffer *buf;
1833{
1834 return(buf->nb_bytecount);
1835}
1836
1837/*
1838 * Get the virtual address and length of a buffer.
1839 * Note: the vaddr argument is optional.
1840 */
1841
1842__stdcall static void
1843ndis_query_buf(buf, vaddr, len)
1844 ndis_buffer *buf;
1845 void **vaddr;
1846 uint32_t *len;
1847{
1848 if (vaddr != NULL)
1849 *vaddr = MDL_VA(buf);
1850 *len = buf->nb_bytecount;
1851
1852 return;
1853}
1854
1855/* Same as above -- we don't care about the priority. */
1856
1857__stdcall static void
1858ndis_query_buf_safe(buf, vaddr, len, prio)
1859 ndis_buffer *buf;
1860 void **vaddr;
1861 uint32_t *len;
1862 uint32_t prio;
1863{
1864 if (vaddr != NULL)
1865 *vaddr = MDL_VA(buf);
1866 *len = buf->nb_bytecount;
1867
1868 return;
1869}
1870
1871/* Damnit Microsoft!! How many ways can you do the same thing?! */
1872
1873__stdcall static void *
1874ndis_buf_vaddr(buf)
1875 ndis_buffer *buf;
1876{
1877 return(MDL_VA(buf));
1878}
1879
1880__stdcall static void *
1881ndis_buf_vaddr_safe(buf, prio)
1882 ndis_buffer *buf;
1883 uint32_t prio;
1884{
1885 return(MDL_VA(buf));
1886}
1887
1888__stdcall static void
1889ndis_adjust_buflen(buf, len)
1890 ndis_buffer *buf;
1891 int len;
1892{
1893 buf->nb_bytecount = len;
1894
1895 return;
1896}
1897
1898__stdcall static uint32_t
1899ndis_interlock_inc(addend)
1900 uint32_t *addend;
1901{
1902 atomic_add_long((u_long *)addend, 1);
1903 return(*addend);
1904}
1905
1906__stdcall static uint32_t
1907ndis_interlock_dec(addend)
1908 uint32_t *addend;
1909{
1910 atomic_subtract_long((u_long *)addend, 1);
1911 return(*addend);
1912}
1913
1914__stdcall static void
1915ndis_init_event(event)
1916 ndis_event *event;
1917{
1918 event->ne_event.nk_header.dh_sigstate = FALSE;
1919 event->ne_event.nk_header.dh_size = OTYPE_EVENT;
1920 event->ne_event.nk_header.dh_type = EVENT_TYPE_NOTIFY;
1921 INIT_LIST_HEAD((&event->ne_event.nk_header.dh_waitlisthead));
1922 return;
1923}
1924
1925__stdcall static void
1926ndis_set_event(event)
1927 ndis_event *event;
1928{
1929 ntoskrnl_wakeup(event);
1930 return;
1931}
1932
1933__stdcall static void
1934ndis_reset_event(event)
1935 ndis_event *event;
1936{
1937 event->ne_event.nk_header.dh_sigstate = FALSE;
1938 return;
1939}
1940
1941/*
1942 * This is a stripped-down version of KeWaitForSingleObject().
1943 * Maybe it ought to just call ntoskrnl_waitforobj() to reduce
1944 * code duplication.
1945 */
1946
1947__stdcall static uint8_t
1948ndis_wait_event(event, msecs)
1949 ndis_event *event;
1950 uint32_t msecs;
1951{
1952 int error;
1953 struct timeval tv;
1954 wait_block w;
1955 struct thread *td = curthread;
1956
1957 mtx_pool_lock(ndis_mtxpool, ntoskrnl_dispatchlock);
1958
1959 if (event->ne_event.nk_header.dh_sigstate == TRUE) {
1960 mtx_pool_unlock(ndis_mtxpool, ntoskrnl_dispatchlock);
1961 return(TRUE);
1962 }
1963
1964 INSERT_LIST_HEAD((&event->ne_event.nk_header.dh_waitlisthead),
1965 (&w.wb_waitlist));
1966
1967 tv.tv_sec = 0;
1968 tv.tv_usec = msecs * 1000;
1969
1970 w.wb_kthread = td;
1971 w.wb_object = &event->ne_event.nk_header;
1972
1973 mtx_pool_unlock(ndis_mtxpool, ntoskrnl_dispatchlock);
1974
1975 if (td->td_proc->p_flag & P_KTHREAD)
1976 error = kthread_suspend(td->td_proc, tvtohz(&tv));
1977 else
1978 error = tsleep(td, PPAUSE|PCATCH, "ndiswe", tvtohz(&tv));
1979
1980 mtx_pool_lock(ndis_mtxpool, ntoskrnl_dispatchlock);
1981
1982 REMOVE_LIST_ENTRY((&w.wb_waitlist));
1983
1984 mtx_pool_unlock(ndis_mtxpool, ntoskrnl_dispatchlock);
1985
1986 return(event->ne_event.nk_header.dh_sigstate);
1987}
1988
1989__stdcall static ndis_status
1990ndis_unicode2ansi(dstr, sstr)
1991 ndis_ansi_string *dstr;
1992 ndis_unicode_string *sstr;
1993{
1994 if (dstr == NULL || sstr == NULL)
1995 return(NDIS_STATUS_FAILURE);
1996 if (ndis_unicode_to_ascii(sstr->nus_buf,
1997 sstr->nus_len, &dstr->nas_buf))
1998 return(NDIS_STATUS_FAILURE);
1999 dstr->nas_len = dstr->nas_maxlen = strlen(dstr->nas_buf);
2000 return (NDIS_STATUS_SUCCESS);
2001}
2002
2003__stdcall static ndis_status
2004ndis_ansi2unicode(dstr, sstr)
2005 ndis_unicode_string *dstr;
2006 ndis_ansi_string *sstr;
2007{
2008 char *str;
2009 if (dstr == NULL || sstr == NULL)
2010 return(NDIS_STATUS_FAILURE);
2011 str = malloc(sstr->nas_len + 1, M_DEVBUF, M_NOWAIT);
2012 if (str == NULL)
2013 return(NDIS_STATUS_FAILURE);
2014 strncpy(str, sstr->nas_buf, sstr->nas_len);
2015 *(str + sstr->nas_len) = '\0';
2016 if (ndis_ascii_to_unicode(str, &dstr->nus_buf)) {
2017 free(str, M_DEVBUF);
2018 return(NDIS_STATUS_FAILURE);
2019 }
2020 dstr->nus_len = dstr->nus_maxlen = sstr->nas_len * 2;
2021 free(str, M_DEVBUF);
2022 return (NDIS_STATUS_SUCCESS);
2023}
2024
2025__stdcall static ndis_status
2026ndis_assign_pcirsrc(adapter, slot, list)
2027 ndis_handle adapter;
2028 uint32_t slot;
2029 ndis_resource_list **list;
2030{
2031 ndis_miniport_block *block;
2032
2033 if (adapter == NULL || list == NULL)
2034 return (NDIS_STATUS_FAILURE);
2035
2036 block = (ndis_miniport_block *)adapter;
2037 *list = block->nmb_rlist;
2038
2039 return (NDIS_STATUS_SUCCESS);
2040}
2041
2042__stdcall static ndis_status
2043ndis_register_intr(intr, adapter, ivec, ilevel, reqisr, shared, imode)
2044 ndis_miniport_interrupt *intr;
2045 ndis_handle adapter;
2046 uint32_t ivec;
2047 uint32_t ilevel;
2048 uint8_t reqisr;
2049 uint8_t shared;
2050 ndis_interrupt_mode imode;
2051{
2052 ndis_miniport_block *block;
2053
2054 block = adapter;
2055
2056 intr->ni_block = adapter;
2057 intr->ni_isrreq = reqisr;
2058 intr->ni_shared = shared;
2059 block->nmb_interrupt = intr;
2060 return(NDIS_STATUS_SUCCESS);
2061}
2062
2063__stdcall static void
2064ndis_deregister_intr(intr)
2065 ndis_miniport_interrupt *intr;
2066{
2067 return;
2068}
2069
2070__stdcall static void
2071ndis_register_shutdown(adapter, shutdownctx, shutdownfunc)
2072 ndis_handle adapter;
2073 void *shutdownctx;
2074 ndis_shutdown_handler shutdownfunc;
2075{
2076 ndis_miniport_block *block;
2077 ndis_miniport_characteristics *chars;
2078 struct ndis_softc *sc;
2079
2080 if (adapter == NULL)
2081 return;
2082
2083 block = (ndis_miniport_block *)adapter;
2084 sc = (struct ndis_softc *)block->nmb_ifp;
2085 chars = &sc->ndis_chars;
2086
2087 chars->nmc_shutdown_handler = shutdownfunc;
2088 chars->nmc_rsvd0 = shutdownctx;
2089
2090 return;
2091}
2092
2093__stdcall static void
2094ndis_deregister_shutdown(adapter)
2095 ndis_handle adapter;
2096{
2097 ndis_miniport_block *block;
2098 ndis_miniport_characteristics *chars;
2099 struct ndis_softc *sc;
2100
2101 if (adapter == NULL)
2102 return;
2103
2104 block = (ndis_miniport_block *)adapter;
2105 sc = (struct ndis_softc *)block->nmb_ifp;
2106 chars = &sc->ndis_chars;
2107
2108 chars->nmc_shutdown_handler = NULL;
2109 chars->nmc_rsvd0 = NULL;
2110
2111 return;
2112}
2113
2114__stdcall static uint32_t
2115ndis_numpages(buf)
2116 ndis_buffer *buf;
2117{
2118 if (buf == NULL)
2119 return(0);
2120 if (buf->nb_bytecount == 0)
2121 return(1);
2122 return(SPAN_PAGES(MDL_VA(buf), buf->nb_bytecount));
2123}
2124
2125__stdcall static void
2126ndis_buf_physpages(buf, pages)
2127 ndis_buffer *buf;
2128 uint32_t *pages;
2129{
2130 if (buf == NULL)
2131 return;
2132
2133 *pages = ndis_numpages(buf);
2134 return;
2135}
2136
2137__stdcall static void
2138ndis_query_bufoffset(buf, off, len)
2139 ndis_buffer *buf;
2140 uint32_t *off;
2141 uint32_t *len;
2142{
2143 if (buf == NULL)
2144 return;
2145
2146 *off = buf->nb_byteoffset;
2147 *len = buf->nb_bytecount;
2148
2149 return;
2150}
2151
2152__stdcall static void
2153ndis_sleep(usecs)
2154 uint32_t usecs;
2155{
2156 struct timeval tv;
2157 uint32_t dummy;
2158
2159 tv.tv_sec = 0;
2160 tv.tv_usec = usecs;
2161
2162 tsleep(&dummy, PPAUSE|PCATCH, "ndis", tvtohz(&tv));
2163
2164 return;
2165}
2166
2167__stdcall static uint32_t
2168ndis_read_pccard_amem(handle, offset, buf, len)
2169 ndis_handle handle;
2170 uint32_t offset;
2171 void *buf;
2172 uint32_t len;
2173{
2174 struct ndis_softc *sc;
2175 ndis_miniport_block *block;
2176 bus_space_handle_t bh;
2177 bus_space_tag_t bt;
2178 char *dest;
2179 int i;
2180
2181 if (handle == NULL)
2182 return(0);
2183
2184 block = (ndis_miniport_block *)handle;
2185 sc = (struct ndis_softc *)block->nmb_ifp;
2186 dest = buf;
2187
2188 bh = rman_get_bushandle(sc->ndis_res_am);
2189 bt = rman_get_bustag(sc->ndis_res_am);
2190
2191 for (i = 0; i < len; i++)
2192 dest[i] = bus_space_read_1(bt, bh, (offset * 2) + (i * 2));
2193
2194 return(i);
2195}
2196
2197__stdcall static uint32_t
2198ndis_write_pccard_amem(handle, offset, buf, len)
2199 ndis_handle handle;
2200 uint32_t offset;
2201 void *buf;
2202 uint32_t len;
2203{
2204 struct ndis_softc *sc;
2205 ndis_miniport_block *block;
2206 bus_space_handle_t bh;
2207 bus_space_tag_t bt;
2208 char *src;
2209 int i;
2210
2211 if (handle == NULL)
2212 return(0);
2213
2214 block = (ndis_miniport_block *)handle;
2215 sc = (struct ndis_softc *)block->nmb_ifp;
2216 src = buf;
2217
2218 bh = rman_get_bushandle(sc->ndis_res_am);
2219 bt = rman_get_bustag(sc->ndis_res_am);
2220
2221 for (i = 0; i < len; i++)
2222 bus_space_write_1(bt, bh, (offset * 2) + (i * 2), src[i]);
2223
2224 return(i);
2225}
2226
2227__stdcall static list_entry *
2228ndis_insert_head(head, entry, lock)
2229 list_entry *head;
2230 list_entry *entry;
2231 ndis_spin_lock *lock;
2232{
2233 list_entry *flink;
2234
2235 mtx_pool_lock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock);
2236 flink = head->nle_flink;
2237 entry->nle_flink = flink;
2238 entry->nle_blink = head;
2239 flink->nle_blink = entry;
2240 head->nle_flink = entry;
2241 mtx_pool_unlock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock);
2242
2243 return(flink);
2244}
2245
2246__stdcall static list_entry *
2247ndis_remove_head(head, lock)
2248 list_entry *head;
2249 ndis_spin_lock *lock;
2250{
2251 list_entry *flink;
2252 list_entry *entry;
2253
2254 mtx_pool_lock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock);
2255 entry = head->nle_flink;
2256 flink = entry->nle_flink;
2257 head->nle_flink = flink;
2258 flink->nle_blink = head;
2259 mtx_pool_unlock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock);
2260
2261 return(entry);
2262}
2263
2264__stdcall static list_entry *
2265ndis_insert_tail(head, entry, lock)
2266 list_entry *head;
2267 list_entry *entry;
2268 ndis_spin_lock *lock;
2269{
2270 list_entry *blink;
2271
2272 mtx_pool_lock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock);
2273 blink = head->nle_blink;
2274 entry->nle_flink = head;
2275 entry->nle_blink = blink;
2276 blink->nle_flink = entry;
2277 head->nle_blink = entry;
2278 mtx_pool_unlock(ndis_mtxpool, (struct mtx *)lock->nsl_spinlock);
2279
2280 return(blink);
2281}
2282
2283__stdcall static uint8_t
2284ndis_sync_with_intr(intr, syncfunc, syncctx)
2285 ndis_miniport_interrupt *intr;
2286 void *syncfunc;
2287 void *syncctx;
2288{
2289 struct ndis_softc *sc;
2290 __stdcall uint8_t (*sync)(void *);
2291 uint8_t rval;
2292
2293 if (syncfunc == NULL || syncctx == NULL)
2294 return(0);
2295
2296 sc = (struct ndis_softc *)intr->ni_block->nmb_ifp;
2297 sync = syncfunc;
2298 mtx_pool_lock(ndis_mtxpool, sc->ndis_intrmtx);
2299 rval = sync(syncctx);
2300 mtx_pool_unlock(ndis_mtxpool, sc->ndis_intrmtx);
2301
2302 return(rval);
2303}
2304
2305/*
2306 * Return the number of 100 nanosecond intervals since
2307 * January 1, 1601. (?!?!)
2308 */
2309__stdcall static void
2310ndis_time(tval)
2311 uint64_t *tval;
2312{
2313 struct timespec ts;
2314
2315 nanotime(&ts);
2316 *tval = (uint64_t)ts.tv_nsec / 100 + (uint64_t)ts.tv_sec * 10000000 +
2317 11644473600;
2318
2319 return;
2320}
2321
2322/*
2323 * Return the number of milliseconds since the system booted.
2324 */
2325__stdcall static void
2326ndis_uptime(tval)
2327 uint32_t *tval;
2328{
2329 struct timespec ts;
2330
2331 nanouptime(&ts);
2332 *tval = ts.tv_nsec / 1000000 + ts.tv_sec * 1000;
2333
2334 return;
2335}
2336
2337__stdcall static void
2338ndis_init_string(dst, src)
2339 ndis_unicode_string *dst;
2340 char *src;
2341{
2342 ndis_unicode_string *u;
2343
2344 u = dst;
2345 u->nus_buf = NULL;
2346 if (ndis_ascii_to_unicode(src, &u->nus_buf))
2347 return;
2348 u->nus_len = u->nus_maxlen = strlen(src) * 2;
2349 return;
2350}
2351
2352__stdcall static void
2353ndis_free_string(str)
2354 ndis_unicode_string *str;
2355{
2356 if (str == NULL)
2357 return;
2358 if (str->nus_buf != NULL)
2359 free(str->nus_buf, M_DEVBUF);
2360 free(str, M_DEVBUF);
2361 return;
2362}
2363
2364__stdcall static ndis_status
2365ndis_remove_miniport(adapter)
2366 ndis_handle *adapter;
2367{
2368 return(NDIS_STATUS_SUCCESS);
2369}
2370
2371__stdcall static void
2372ndis_init_ansi_string(dst, src)
2373 ndis_ansi_string *dst;
2374 char *src;
2375{
2376 ndis_ansi_string *a;
2377
2378 a = dst;
2379 if (a == NULL)
2380 return;
2381 if (src == NULL) {
2382 a->nas_len = a->nas_maxlen = 0;
2383 a->nas_buf = NULL;
2384 } else {
2385 a->nas_buf = src;
2386 a->nas_len = a->nas_maxlen = strlen(src);
2387 }
2388
2389 return;
2390}
2391
2392__stdcall static void
2393ndis_init_unicode_string(dst, src)
2394 ndis_unicode_string *dst;
2395 uint16_t *src;
2396{
2397 ndis_unicode_string *u;
2398 int i;
2399
2400 u = dst;
2401 if (u == NULL)
2402 return;
2403 if (src == NULL) {
2404 u->nus_len = u->nus_maxlen = 0;
2405 u->nus_buf = NULL;
2406 } else {
2407 i = 0;
2408 while(src[i] != 0)
2409 i++;
2410 u->nus_buf = src;
2411 u->nus_len = u->nus_maxlen = i * 2;
2412 }
2413
2414 return;
2415}
2416
2417__stdcall static void ndis_get_devprop(adapter, phydevobj,
2418 funcdevobj, nextdevobj, resources, transresources)
2419 ndis_handle adapter;
2420 device_object **phydevobj;
2421 device_object **funcdevobj;
2422 device_object **nextdevobj;
2423 cm_resource_list *resources;
2424 cm_resource_list *transresources;
2425{
2426 ndis_miniport_block *block;
2427
2428 block = (ndis_miniport_block *)adapter;
2429
2430 if (phydevobj != NULL)
2431 *phydevobj = &block->nmb_devobj;
2432 if (funcdevobj != NULL)
2433 *funcdevobj = &block->nmb_devobj;
2434
2435 return;
2436}
2437
2438__stdcall static void
2439ndis_firstbuf(packet, buf, firstva, firstlen, totlen)
2440 ndis_packet *packet;
2441 ndis_buffer **buf;
2442 void **firstva;
2443 uint32_t *firstlen;
2444 uint32_t *totlen;
2445{
2446 ndis_buffer *tmp;
2447
2448 tmp = packet->np_private.npp_head;
2449 *buf = tmp;
2450 if (tmp == NULL) {
2451 *firstva = NULL;
2452 *firstlen = *totlen = 0;
2453 } else {
2454 *firstva = MDL_VA(tmp);
2455 *firstlen = *totlen = tmp->nb_bytecount;
2456 for (tmp = tmp->nb_next; tmp != NULL; tmp = tmp->nb_next)
2457 *totlen += tmp->nb_bytecount;
2458 }
2459
2460 return;
2461}
2462
2463__stdcall static void
2464ndis_firstbuf_safe(packet, buf, firstva, firstlen, totlen, prio)
2465 ndis_packet *packet;
2466 ndis_buffer **buf;
2467 void **firstva;
2468 uint32_t *firstlen;
2469 uint32_t *totlen;
2470 uint32_t prio;
2471{
2472 ndis_firstbuf(packet, buf, firstva, firstlen, totlen);
2473}
2474
2475/* can also return NDIS_STATUS_RESOURCES/NDIS_STATUS_ERROR_READING_FILE */
2476__stdcall static void
2477ndis_open_file(status, filehandle, filelength, filename, highestaddr)
2478 ndis_status *status;
2479 ndis_handle *filehandle;
2480 uint32_t *filelength;
2481 ndis_unicode_string *filename;
2482 ndis_physaddr highestaddr;
2483{
2484 char *afilename = NULL;
2485 struct thread *td = curthread;
2486 struct nameidata nd;
2487 int flags, error;
2488 struct vattr vat;
2489 struct vattr *vap = &vat;
2490 ndis_fh *fh;
2491 char path[MAXPATHLEN];
2492
2493 ndis_unicode_to_ascii(filename->nus_buf,
2494 filename->nus_len, &afilename);
2495
2496 sprintf(path, "%s/%s", ndis_filepath, afilename);
2497 free(afilename, M_DEVBUF);
2498
2499 fh = malloc(sizeof(ndis_fh), M_TEMP, M_NOWAIT);
2500 if (fh == NULL) {
2501 *status = NDIS_STATUS_RESOURCES;
2502 return;
2503 }
2504
2505 mtx_lock(&Giant);
2506
2507 /* Some threads don't have a current working directory. */
2508
2509 if (td->td_proc->p_fd->fd_rdir == NULL)
2510 td->td_proc->p_fd->fd_rdir = rootvnode;
2511 if (td->td_proc->p_fd->fd_cdir == NULL)
2512 td->td_proc->p_fd->fd_cdir = rootvnode;
2513
2514 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, td);
2515
2516 flags = FREAD;
2517 error = vn_open(&nd, &flags, 0, -1);
2518 if (error) {
2519 mtx_unlock(&Giant);
2520 *status = NDIS_STATUS_FILE_NOT_FOUND;
2521 free(fh, M_TEMP);
2522 return;
2523 }
2524
2525 NDFREE(&nd, NDF_ONLY_PNBUF);
2526
2527 /* Get the file size. */
2528 VOP_GETATTR(nd.ni_vp, vap, NOCRED, td);
2529 VOP_UNLOCK(nd.ni_vp, 0, td);
2530 mtx_unlock(&Giant);
2531
2532 fh->nf_vp = nd.ni_vp;
2533 fh->nf_map = NULL;
2534 *filehandle = fh;
2535 *filelength = fh->nf_maplen = vap->va_size & 0xFFFFFFFF;
2536 *status = NDIS_STATUS_SUCCESS;
2537 return;
2538}
2539
2540__stdcall static void
2541ndis_map_file(status, mappedbuffer, filehandle)
2542 ndis_status *status;
2543 void **mappedbuffer;
2544 ndis_handle filehandle;
2545{
2546 ndis_fh *fh;
2547 struct thread *td = curthread;
2548 int error, resid;
2549
2550 if (filehandle == NULL) {
2551 *status = NDIS_STATUS_FAILURE;
2552 return;
2553 }
2554
2555 fh = (ndis_fh *)filehandle;
2556
2557 if (fh->nf_vp == NULL) {
2558 *status = NDIS_STATUS_FAILURE;
2559 return;
2560 }
2561
2562 if (fh->nf_map != NULL) {
2563 *status = NDIS_STATUS_ALREADY_MAPPED;
2564 return;
2565 }
2566
2567 fh->nf_map = malloc(fh->nf_maplen, M_DEVBUF, M_NOWAIT);
2568
2569 if (fh->nf_map == NULL) {
2570 *status = NDIS_STATUS_RESOURCES;
2571 return;
2572 }
2573
2574 mtx_lock(&Giant);
2575 error = vn_rdwr(UIO_READ, fh->nf_vp, fh->nf_map, fh->nf_maplen, 0,
2576 UIO_SYSSPACE, 0, td->td_ucred, NOCRED, &resid, td);
2577 mtx_unlock(&Giant);
2578
2579 if (error)
2580 *status = NDIS_STATUS_FAILURE;
2581 else {
2582 *status = NDIS_STATUS_SUCCESS;
2583 *mappedbuffer = fh->nf_map;
2584 }
2585
2586 return;
2587}
2588
2589__stdcall static void
2590ndis_unmap_file(filehandle)
2591 ndis_handle filehandle;
2592{
2593 ndis_fh *fh;
2594 fh = (ndis_fh *)filehandle;
2595
2596 if (fh->nf_map == NULL)
2597 return;
2598 free(fh->nf_map, M_DEVBUF);
2599 fh->nf_map = NULL;
2600
2601 return;
2602}
2603
2604__stdcall static void
2605ndis_close_file(filehandle)
2606 ndis_handle filehandle;
2607{
2608 struct thread *td = curthread;
2609 ndis_fh *fh;
2610
2611 if (filehandle == NULL)
2612 return;
2613
2614 fh = (ndis_fh *)filehandle;
2615 if (fh->nf_map != NULL) {
2616 free(fh->nf_map, M_DEVBUF);
2617 fh->nf_map = NULL;
2618 }
2619
2620 if (fh->nf_vp == NULL)
2621 return;
2622
2623 mtx_lock(&Giant);
2624 vn_close(fh->nf_vp, FREAD, td->td_ucred, td);
2625 mtx_unlock(&Giant);
2626
2627 fh->nf_vp = NULL;
2628 free(fh, M_DEVBUF);
2629
2630 return;
2631}
2632
2633__stdcall static uint8_t
2634ndis_cpu_cnt()
2635{
2636 return(mp_ncpus);
2637}
2638
2639typedef void (*ndis_statusdone_handler)(ndis_handle);
2640typedef void (*ndis_status_handler)(ndis_handle, ndis_status,
2641 void *, uint32_t);
2642
2643__stdcall static void
2644ndis_ind_statusdone(adapter)
2645 ndis_handle adapter;
2646{
2647 ndis_miniport_block *block;
2648 __stdcall ndis_statusdone_handler statusdonefunc;
2649
2650 block = (ndis_miniport_block *)adapter;
2651 statusdonefunc = block->nmb_statusdone_func;
2652
2653 statusdonefunc(adapter);
2654 return;
2655}
2656
2657__stdcall static void
2658ndis_ind_status(adapter, status, sbuf, slen)
2659 ndis_handle adapter;
2660 ndis_status status;
2661 void *sbuf;
2662 uint32_t slen;
2663{
2664 ndis_miniport_block *block;
2665 __stdcall ndis_status_handler statusfunc;
2666
2667 block = (ndis_miniport_block *)adapter;
2668 statusfunc = block->nmb_status_func;
2669
2670 statusfunc(adapter, status, sbuf, slen);
2671 return;
2672}
2673
2674static void
2675ndis_workfunc(ctx)
2676 void *ctx;
2677{
2678 ndis_work_item *work;
2679 __stdcall ndis_proc workfunc;
2680
2681 work = ctx;
2682 workfunc = work->nwi_func;
2683 workfunc(work, work->nwi_ctx);
2684 return;
2685}
2686
2687__stdcall static ndis_status
2688ndis_sched_workitem(work)
2689 ndis_work_item *work;
2690{
2691 ndis_sched(ndis_workfunc, work, NDIS_TASKQUEUE);
2692 return(NDIS_STATUS_SUCCESS);
2693}
2694
2695__stdcall static void
2696ndis_pkt_to_pkt(dpkt, doff, reqlen, spkt, soff, cpylen)
2697 ndis_packet *dpkt;
2698 uint32_t doff;
2699 uint32_t reqlen;
2700 ndis_packet *spkt;
2701 uint32_t soff;
2702 uint32_t *cpylen;
2703{
2704 ndis_buffer *src, *dst;
2705 char *sptr, *dptr;
2706 int resid, copied, len, scnt, dcnt;
2707
2708 *cpylen = 0;
2709
2710 src = spkt->np_private.npp_head;
2711 dst = dpkt->np_private.npp_head;
2712
2713 sptr = MDL_VA(src);
2714 dptr = MDL_VA(dst);
2715 scnt = src->nb_bytecount;
2716 dcnt = dst->nb_bytecount;
2717
2718 while (soff) {
2719 if (src->nb_bytecount > soff) {
2720 sptr += soff;
2721 scnt = src->nb_bytecount - soff;
2722 break;
2723 }
2724 soff -= src->nb_bytecount;
2725 src = src->nb_next;
2726 if (src == NULL)
2727 return;
2728 sptr = MDL_VA(src);
2729 }
2730
2731 while (doff) {
2732 if (dst->nb_bytecount > doff) {
2733 dptr += doff;
2734 dcnt = dst->nb_bytecount - doff;
2735 break;
2736 }
2737 doff -= dst->nb_bytecount;
2738 dst = dst->nb_next;
2739 if (dst == NULL)
2740 return;
2741 dptr = MDL_VA(dst);
2742 }
2743
2744 resid = reqlen;
2745 copied = 0;
2746
2747 while(1) {
2748 if (resid < scnt)
2749 len = resid;
2750 else
2751 len = scnt;
2752 if (dcnt < len)
2753 len = dcnt;
2754
2755 bcopy(sptr, dptr, len);
2756
2757 copied += len;
2758 resid -= len;
2759 if (resid == 0)
2760 break;
2761
2762 dcnt -= len;
2763 if (dcnt == 0) {
2764 dst = dst->nb_next;
2765 if (dst == NULL)
2766 break;
2767 dptr = MDL_VA(dst);
2768 dcnt = dst->nb_bytecount;
2769 }
2770
2771 scnt -= len;
2772 if (scnt == 0) {
2773 src = src->nb_next;
2774 if (src == NULL)
2775 break;
2776 sptr = MDL_VA(src);
2777 scnt = src->nb_bytecount;
2778 }
2779 }
2780
2781 *cpylen = copied;
2782 return;
2783}
2784
2785__stdcall static void
2786ndis_pkt_to_pkt_safe(dpkt, doff, reqlen, spkt, soff, cpylen, prio)
2787 ndis_packet *dpkt;
2788 uint32_t doff;
2789 uint32_t reqlen;
2790 ndis_packet *spkt;
2791 uint32_t soff;
2792 uint32_t *cpylen;
2793 uint32_t prio;
2794{
2795 ndis_pkt_to_pkt(dpkt, doff, reqlen, spkt, soff, cpylen);
2796 return;
2797}
2798
2799__stdcall static ndis_status
2800ndis_register_dev(handle, devname, symname, majorfuncs, devobj, devhandle)
2801 ndis_handle handle;
2802 ndis_unicode_string *devname;
2803 ndis_unicode_string *symname;
2804 driver_dispatch *majorfuncs[];
2805 void **devobj;
2806 ndis_handle *devhandle;
2807{
2808 ndis_miniport_block *block;
2809
2810 block = (ndis_miniport_block *)handle;
2811 *devobj = &block->nmb_devobj;
2812 *devhandle = handle;
2813
2814 return(NDIS_STATUS_SUCCESS);
2815}
2816
2817__stdcall static ndis_status
2818ndis_deregister_dev(handle)
2819 ndis_handle handle;
2820{
2821 return(NDIS_STATUS_SUCCESS);
2822}
2823
2824__stdcall static ndis_status
2825ndis_query_name(name, handle)
2826 ndis_unicode_string *name;
2827 ndis_handle handle;
2828{
2829 ndis_miniport_block *block;
2830
2831 block = (ndis_miniport_block *)handle;
2832 ndis_ascii_to_unicode(__DECONST(char *,
2833 device_get_nameunit(block->nmb_dev)), &name->nus_buf);
2834 name->nus_len = strlen(device_get_nameunit(block->nmb_dev)) * 2;
2835
2836 return(NDIS_STATUS_SUCCESS);
2837}
2838
2839__stdcall static void
2840ndis_register_unload(handle, func)
2841 ndis_handle handle;
2842 void *func;
2843{
2844 return;
2845}
2846
2847__stdcall static void
2848dummy()
2849{
2850 printf ("NDIS dummy called...\n");
2851 return;
2852}
2853
2854image_patch_table ndis_functbl[] = {
2855 { "NdisCopyFromPacketToPacket", (FUNC)ndis_pkt_to_pkt },
2856 { "NdisCopyFromPacketToPacketSafe", (FUNC)ndis_pkt_to_pkt_safe },
2857 { "NdisScheduleWorkItem", (FUNC)ndis_sched_workitem },
2858 { "NdisMIndicateStatusComplete", (FUNC)ndis_ind_statusdone },
2859 { "NdisMIndicateStatus", (FUNC)ndis_ind_status },
2860 { "NdisSystemProcessorCount", (FUNC)ndis_cpu_cnt },
2861 { "NdisUnchainBufferAtBack", (FUNC)ndis_unchain_tailbuf, },
2862 { "NdisGetFirstBufferFromPacket", (FUNC)ndis_firstbuf },
2863 { "NdisGetFirstBufferFromPacketSafe", (FUNC)ndis_firstbuf_safe },
2864 { "NdisGetBufferPhysicalArraySize", (FUNC)ndis_buf_physpages },
2865 { "NdisMGetDeviceProperty", (FUNC)ndis_get_devprop },
2866 { "NdisInitAnsiString", (FUNC)ndis_init_ansi_string },
2867 { "NdisInitUnicodeString", (FUNC)ndis_init_unicode_string },
2868 { "NdisWriteConfiguration", (FUNC)ndis_write_cfg },
2869 { "NdisAnsiStringToUnicodeString", (FUNC)ndis_ansi2unicode },
2870 { "NdisTerminateWrapper", (FUNC)ndis_termwrap },
2871 { "NdisOpenConfigurationKeyByName", (FUNC)ndis_open_cfgbyname },
2872 { "NdisOpenConfigurationKeyByIndex", (FUNC)ndis_open_cfgbyidx },
2873 { "NdisMRemoveMiniport", (FUNC)ndis_remove_miniport },
2874 { "NdisInitializeString", (FUNC)ndis_init_string },
2875 { "NdisFreeString", (FUNC)ndis_free_string },
2876 { "NdisGetCurrentSystemTime", (FUNC)ndis_time },
2877 { "NdisGetSystemUpTime", (FUNC)ndis_uptime },
2878 { "NdisMSynchronizeWithInterrupt", (FUNC)ndis_sync_with_intr },
2879 { "NdisMAllocateSharedMemoryAsync", (FUNC)ndis_alloc_sharedmem_async },
2880 { "NdisInterlockedInsertHeadList", (FUNC)ndis_insert_head },
2881 { "NdisInterlockedInsertTailList", (FUNC)ndis_insert_tail },
2882 { "NdisInterlockedRemoveHeadList", (FUNC)ndis_remove_head },
2883 { "NdisInitializeWrapper", (FUNC)ndis_initwrap },
2884 { "NdisMRegisterMiniport", (FUNC)ndis_register_miniport },
2885 { "NdisAllocateMemoryWithTag", (FUNC)ndis_malloc_withtag },
2886 { "NdisAllocateMemory", (FUNC)ndis_malloc },
2887 { "NdisMSetAttributesEx", (FUNC)ndis_setattr_ex },
2888 { "NdisCloseConfiguration", (FUNC)ndis_close_cfg },
2889 { "NdisReadConfiguration", (FUNC)ndis_read_cfg },
2890 { "NdisOpenConfiguration", (FUNC)ndis_open_cfg },
2891 { "NdisReleaseSpinLock", (FUNC)ndis_unlock },
2892 { "NdisDprAcquireSpinLock", (FUNC)ndis_lock },
2893 { "NdisDprReleaseSpinLock", (FUNC)ndis_unlock },
2894 { "NdisAcquireSpinLock", (FUNC)ndis_lock },
2895 { "NdisAllocateSpinLock", (FUNC)ndis_create_lock },
2896 { "NdisFreeSpinLock", (FUNC)ndis_destroy_lock },
2897 { "NdisFreeMemory", (FUNC)ndis_free },
2898 { "NdisReadPciSlotInformation", (FUNC)ndis_read_pci },
2899 { "NdisWritePciSlotInformation",(FUNC)ndis_write_pci },
2900 { "NdisImmediateReadPciSlotInformation", (FUNC)ndis_read_pci },
2901 { "NdisImmediateWritePciSlotInformation", (FUNC)ndis_write_pci },
2902 { "NdisWriteErrorLogEntry", (FUNC)ndis_syslog },
2903 { "NdisMStartBufferPhysicalMapping", (FUNC)ndis_vtophys_load },
2904 { "NdisMCompleteBufferPhysicalMapping", (FUNC)ndis_vtophys_unload },
2905 { "NdisMInitializeTimer", (FUNC)ndis_create_timer },
2906 { "NdisInitializeTimer", (FUNC)ndis_init_timer },
2907 { "NdisSetTimer", (FUNC)ndis_set_timer },
2908 { "NdisMCancelTimer", (FUNC)ndis_cancel_timer },
2909 { "NdisCancelTimer", (FUNC)ndis_cancel_timer },
2910 { "NdisMSetPeriodicTimer", (FUNC)ndis_set_periodic_timer },
2911 { "NdisMQueryAdapterResources", (FUNC)ndis_query_resources },
2912 { "NdisMRegisterIoPortRange", (FUNC)ndis_register_ioport },
2913 { "NdisMDeregisterIoPortRange", (FUNC)ndis_deregister_ioport },
2914 { "NdisReadNetworkAddress", (FUNC)ndis_read_netaddr },
2915 { "NdisQueryMapRegisterCount", (FUNC)ndis_mapreg_cnt },
2916 { "NdisMAllocateMapRegisters", (FUNC)ndis_alloc_mapreg },
2917 { "NdisMFreeMapRegisters", (FUNC)ndis_free_mapreg },
2918 { "NdisMAllocateSharedMemory", (FUNC)ndis_alloc_sharedmem },
2919 { "NdisMMapIoSpace", (FUNC)ndis_map_iospace },
2920 { "NdisMUnmapIoSpace", (FUNC)ndis_unmap_iospace },
2921 { "NdisGetCacheFillSize", (FUNC)ndis_cachefill },
2922 { "NdisMGetDmaAlignment", (FUNC)ndis_dma_align },
2923 { "NdisMInitializeScatterGatherDma", (FUNC)ndis_init_sc_dma },
2924 { "NdisAllocatePacketPool", (FUNC)ndis_alloc_packetpool },
2925 { "NdisAllocatePacketPoolEx", (FUNC)ndis_ex_alloc_packetpool },
2926 { "NdisAllocatePacket", (FUNC)ndis_alloc_packet },
2927 { "NdisFreePacket", (FUNC)ndis_release_packet },
2928 { "NdisFreePacketPool", (FUNC)ndis_free_packetpool },
2929 { "NdisDprAllocatePacket", (FUNC)ndis_alloc_packet },
2930 { "NdisDprFreePacket", (FUNC)ndis_release_packet },
2931 { "NdisAllocateBufferPool", (FUNC)ndis_alloc_bufpool },
2932 { "NdisAllocateBuffer", (FUNC)ndis_alloc_buf },
2933 { "NdisQueryBuffer", (FUNC)ndis_query_buf },
2934 { "NdisQueryBufferSafe", (FUNC)ndis_query_buf_safe },
2935 { "NdisBufferVirtualAddress", (FUNC)ndis_buf_vaddr },
2936 { "NdisBufferVirtualAddressSafe", (FUNC)ndis_buf_vaddr_safe },
2937 { "NdisBufferLength", (FUNC)ndis_buflen },
2938 { "NdisFreeBuffer", (FUNC)ndis_release_buf },
2939 { "NdisFreeBufferPool", (FUNC)ndis_free_bufpool },
2940 { "NdisInterlockedIncrement", (FUNC)ndis_interlock_inc },
2941 { "NdisInterlockedDecrement", (FUNC)ndis_interlock_dec },
2942 { "NdisInitializeEvent", (FUNC)ndis_init_event },
2943 { "NdisSetEvent", (FUNC)ndis_set_event },
2944 { "NdisResetEvent", (FUNC)ndis_reset_event },
2945 { "NdisWaitEvent", (FUNC)ndis_wait_event },
2946 { "NdisUnicodeStringToAnsiString", (FUNC)ndis_unicode2ansi },
2947 { "NdisMPciAssignResources", (FUNC)ndis_assign_pcirsrc },
2948 { "NdisMFreeSharedMemory", (FUNC)ndis_free_sharedmem },
2949 { "NdisMRegisterInterrupt", (FUNC)ndis_register_intr },
2950 { "NdisMDeregisterInterrupt", (FUNC)ndis_deregister_intr },
2951 { "NdisMRegisterAdapterShutdownHandler", (FUNC)ndis_register_shutdown },
2952 { "NdisMDeregisterAdapterShutdownHandler", (FUNC)ndis_deregister_shutdown },
2953 { "NDIS_BUFFER_TO_SPAN_PAGES", (FUNC)ndis_numpages },
2954 { "NdisQueryBufferOffset", (FUNC)ndis_query_bufoffset },
2955 { "NdisAdjustBufferLength", (FUNC)ndis_adjust_buflen },
2956 { "NdisPacketPoolUsage", (FUNC)ndis_packetpool_use },
2957 { "NdisMSleep", (FUNC)ndis_sleep },
2958 { "NdisUnchainBufferAtFront", (FUNC)ndis_unchain_headbuf },
2959 { "NdisReadPcmciaAttributeMemory", (FUNC)ndis_read_pccard_amem },
2960 { "NdisWritePcmciaAttributeMemory", (FUNC)ndis_write_pccard_amem },
2961 { "NdisOpenFile", (FUNC)ndis_open_file },
2962 { "NdisMapFile", (FUNC)ndis_map_file },
2963 { "NdisUnmapFile", (FUNC)ndis_unmap_file },
2964 { "NdisCloseFile", (FUNC)ndis_close_file },
2965 { "NdisMRegisterDevice", (FUNC)ndis_register_dev },
2966 { "NdisMDeregisterDevice", (FUNC)ndis_deregister_dev },
2967 { "NdisMQueryAdapterInstanceName", (FUNC)ndis_query_name },
2968 { "NdisMRegisterUnloadHandler", (FUNC)ndis_register_unload },
2969
2970 /*
2971 * This last entry is a catch-all for any function we haven't
2972 * implemented yet. The PE import list patching routine will
2973 * use it for any function that doesn't have an explicit match
2974 * in this table.
2975 */
2976
2977 { NULL, (FUNC)dummy },
2978
2979 /* End of list. */
2980
2981 { NULL, NULL },
2982};