2 * Copyright (c) 1998, Larry Lile
5 * For latest sources and information on this driver, please
6 * go to http://anarchy.stdio.com.
8 * Questions, comments or suggestions should be directed to
9 * Larry Lile <lile@stdio.com>.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice unmodified, this list of conditions, and the following
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * $FreeBSD: src/sys/contrib/dev/oltr/if_oltr.c,v 1.11.2.5 2001/10/20 04:15:21 mdodd Exp $
34 * $DragonFly: src/sys/contrib/dev/oltr/Attic/if_oltr.c,v 1.14 2004/07/23 07:16:24 joerg Exp $
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/sockio.h>
41 #include <sys/malloc.h>
42 #include <sys/kernel.h>
43 #include <sys/socket.h>
44 #include <sys/param.h>
47 #include <net/if_arp.h>
48 #include <net/iso88025.h>
49 #include <net/ethernet.h>
50 #include <net/if_dl.h>
51 #include <net/if_media.h>
52 #include <net/iso88025.h>
54 #if defined(__DragonFly__) || (NBPFILTER > 0)
58 #include <vm/vm.h> /* for vtophys */
59 #include <vm/pmap.h> /* for vtophys */
60 #include <machine/bus_memio.h>
61 #include <machine/bus_pio.h>
62 #include <machine/bus.h>
63 #include <machine/resource.h>
64 #include <machine/clock.h>
68 #include <bus/pci/pcireg.h>
69 #include <bus/pci/pcivar.h>
71 #include "contrib/dev/oltr/trlld.h"
73 /*#define DEBUG_MASK DEBUG_POLL*/
76 #define DEBUG_MASK 0x0000
79 #define DEBUG_POLL 0x0001
80 #define DEBUG_INT 0x0002
81 #define DEBUG_INIT 0x0004
82 #define DEBUG_FN_ENT 0x8000
84 #define PCI_VENDOR_OLICOM 0x108D
86 #define MIN3(A,B,C) (MIN(A, (MIN(B, C))))
88 char *AdapterName[] = {
89 /* 0 */ "Olicom XT Adapter [unsupported]",
90 /* 1 */ "Olicom OC-3115",
91 /* 2 */ "Olicom ISA 16/4 Adapter (OC-3117)",
92 /* 3 */ "Olicom ISA 16/4 Adapter (OC-3118)",
93 /* 4 */ "Olicom MCA 16/4 Adapter (OC-3129) [unsupported]",
94 /* 5 */ "Olicom MCA 16/4 Adapter (OC-3129) [unsupported]",
95 /* 6 */ "Olicom MCA 16/4 Adapter (OC-3129) [unsupported]",
96 /* 7 */ "Olicom EISA 16/4 Adapter (OC-3133)",
97 /* 8 */ "Olicom EISA 16/4 Adapter (OC-3133)",
98 /* 9 */ "Olicom EISA 16/4 Server Adapter (OC-3135)",
99 /* 10 */ "Olicom PCI 16/4 Adapter (OC-3136)",
100 /* 11 */ "Olicom PCI 16/4 Adapter (OC-3136)",
101 /* 12 */ "Olicom PCI/II 16/4 Adapter (OC-3137)",
102 /* 13 */ "Olicom PCI 16/4 Adapter (OC-3139)",
103 /* 14 */ "Olicom RapidFire 3140 16/4 PCI Adapter (OC-3140)",
104 /* 15 */ "Olicom RapidFire 3141 Fiber Adapter (OC-3141)",
105 /* 16 */ "Olicom PCMCIA 16/4 Adapter (OC-3220) [unsupported]",
106 /* 17 */ "Olicom PCMCIA 16/4 Adapter (OC-3121, OC-3230, OC-3232) [unsupported]",
107 /* 18 */ "Olicom PCMCIA 16/4 Adapter (OC-3250)",
108 /* 19 */ "Olicom RapidFire 3540 100/16/4 Adapter (OC-3540)"
112 * Glue function prototypes for PMW kit IO
115 #ifndef TRlldInlineIO
116 static void DriverOutByte (unsigned short, unsigned char);
117 static void DriverOutWord (unsigned short, unsigned short);
118 static void DriverOutDword (unsigned short, unsigned long);
119 static void DriverRepOutByte (unsigned short, unsigned char *, int);
120 static void DriverRepOutWord (unsigned short, unsigned short *, int);
121 static void DriverRepOutDword (unsigned short, unsigned long *, int);
122 static unsigned char DriverInByte (unsigned short);
123 static unsigned short DriverInWord (unsigned short);
124 static unsigned long DriverInDword (unsigned short);
125 static void DriverRepInByte (unsigned short, unsigned char *, int);
126 static void DriverRepInWord (unsigned short, unsigned short *, int);
127 static void DriverRepInDword (unsigned short, unsigned long *, int);
128 #endif /*TRlldInlineIO*/
129 static void DriverSuspend (unsigned short);
130 static void DriverStatus (void *, TRlldStatus_t *);
131 static void DriverCloseCompleted (void *);
132 static void DriverStatistics (void *, TRlldStatistics_t *);
133 static void DriverTransmitFrameCompleted (void *, void *, int);
134 static void DriverReceiveFrameCompleted (void *, int, int, void *, int);
136 static TRlldDriver_t LldDriver = {
138 #ifndef TRlldInlineIO
151 #endif /*TRlldInlineIO*/
154 DriverCloseCompleted,
156 DriverTransmitFrameCompleted,
157 DriverReceiveFrameCompleted,
172 #define RING_BUFFER_LEN 16
173 #define RING_BUFFER(x) ((RING_BUFFER_LEN - 1) & x)
174 #define RX_BUFFER_LEN 2048
175 #define TX_BUFFER_LEN 2048
178 struct arpcom arpcom;
179 struct ifmedia ifmedia;
180 bus_space_handle_t oltr_bhandle;
181 bus_space_tag_t oltr_btag;
183 struct resource *oltr_irq;
184 struct resource *oltr_res;
196 struct oltr_rx_buf rx_ring[RING_BUFFER_LEN];
197 int tx_head, tx_avail, tx_frame;
198 struct oltr_tx_buf tx_ring[RING_BUFFER_LEN];
199 TRlldTransmit_t frame_ring[RING_BUFFER_LEN];
200 struct mbuf *restart;
201 TRlldAdapter_t TRlldAdapter;
202 TRlldStatistics_t statistics;
203 TRlldStatistics_t current;
204 TRlldAdapterConfig_t config;
207 u_long FunctionalAddress;
208 struct callout_handle oltr_poll_ch;
209 /*struct callout_handle oltr_stat_ch;*/
213 #define SELF_TEST_POLLS 32
215 void oltr_poll (void *);
216 /*void oltr_stat (void *);*/
218 static void oltr_start (struct ifnet *);
219 static void oltr_stop (struct oltr_softc *);
220 static void oltr_close (struct oltr_softc *);
221 static void oltr_init (void *);
222 static int oltr_ioctl (struct ifnet *, u_long, caddr_t,
224 static void oltr_intr (void *);
225 static int oltr_ifmedia_upd (struct ifnet *);
226 static void oltr_ifmedia_sts (struct ifnet *, struct ifmediareq *);
228 #if defined(__DragonFly__) || __FreeBSD_version > 400000
230 static int oltr_pci_probe (device_t);
231 static int oltr_pci_attach (device_t);
232 static int oltr_pci_detach (device_t);
233 static void oltr_pci_shutdown (device_t);
235 static device_method_t oltr_methods[] = {
236 DEVMETHOD(device_probe, oltr_pci_probe),
237 DEVMETHOD(device_attach, oltr_pci_attach),
238 DEVMETHOD(device_detach, oltr_pci_detach),
239 DEVMETHOD(device_shutdown, oltr_pci_shutdown),
243 static driver_t oltr_driver = {
246 sizeof(struct oltr_softc)
249 static devclass_t oltr_devclass;
251 DRIVER_MODULE(oltr, pci, oltr_driver, oltr_devclass, 0, 0);
254 oltr_pci_probe(device_t dev)
257 char PCIConfigHeader[64];
258 TRlldAdapterConfig_t config;
260 if ((pci_get_vendor(dev) == PCI_VENDOR_OLICOM) &&
261 ((pci_get_device(dev) == 0x0001) ||
262 (pci_get_device(dev) == 0x0004) ||
263 (pci_get_device(dev) == 0x0005) ||
264 (pci_get_device(dev) == 0x0007) ||
265 (pci_get_device(dev) == 0x0008))) {
267 for (i = 0; i < sizeof(PCIConfigHeader); i++)
268 PCIConfigHeader[i] = pci_read_config(dev, i, 1);
270 rc = TRlldPCIConfig(&LldDriver, &config, PCIConfigHeader);
271 if (rc == TRLLD_PCICONFIG_FAIL) {
272 device_printf(dev, "TRlldPciConfig failed!\n");
275 if (rc == TRLLD_PCICONFIG_VERSION) {
276 device_printf(dev, "wrong LLD version\n");
279 device_set_desc(dev, AdapterName[config.type]);
286 oltr_pci_attach(device_t dev)
288 int i, s, rc = 0, rid,
290 int media = IFM_TOKEN|IFM_TOK_UTP16;
292 char PCIConfigHeader[64];
293 struct oltr_softc *sc = device_get_softc(dev);
294 struct ifnet *ifp = &sc->arpcom.ac_if;
298 bzero(sc, sizeof(struct oltr_softc));
299 sc->unit = device_get_unit(dev);
300 sc->state = OL_UNKNOWN;
302 for (i = 0; i < sizeof(PCIConfigHeader); i++)
303 PCIConfigHeader[i] = pci_read_config(dev, i, 1);
305 switch(TRlldPCIConfig(&LldDriver, &sc->config, PCIConfigHeader)) {
306 case TRLLD_PCICONFIG_OK:
308 case TRLLD_PCICONFIG_SET_COMMAND:
309 device_printf(dev, "enabling bus master mode\n");
310 command = pci_read_config(dev, PCIR_COMMAND, 4);
311 pci_write_config(dev, PCIR_COMMAND,
312 (command | PCIM_CMD_BUSMASTEREN), 4);
313 command = pci_read_config(dev, PCIR_COMMAND, 4);
314 if (!(command & PCIM_CMD_BUSMASTEREN)) {
315 device_printf(dev, "failed to enable bus master mode\n");
319 case TRLLD_PCICONFIG_FAIL:
320 device_printf(dev, "TRlldPciConfig failed!\n");
323 case TRLLD_PCICONFIG_VERSION:
324 device_printf(dev, "wrong LLD version\n");
328 device_printf(dev, "MAC address %6D\n", sc->config.macaddress, ":");
330 scratch_size = TRlldAdapterSize();
332 device_printf(dev, "adapter memory block size %d bytes\n", scratch_size);
333 sc->TRlldAdapter = (TRlldAdapter_t)malloc(scratch_size, M_DEVBUF, M_NOWAIT);
334 if (sc->TRlldAdapter == NULL) {
335 device_printf(dev, "couldn't allocate scratch buffer (%d bytes)\n", scratch_size);
340 * Allocate RX/TX Pools
342 for (i = 0; i < RING_BUFFER_LEN; i++) {
343 sc->rx_ring[i].index = i;
344 sc->rx_ring[i].data = (char *)malloc(RX_BUFFER_LEN, M_DEVBUF, M_NOWAIT);
345 sc->rx_ring[i].address = vtophys(sc->rx_ring[i].data);
346 sc->tx_ring[i].index = i;
347 sc->tx_ring[i].data = (char *)malloc(TX_BUFFER_LEN, M_DEVBUF, M_NOWAIT);
348 sc->tx_ring[i].address = vtophys(sc->tx_ring[i].data);
349 if ((!sc->rx_ring[i].data) || (!sc->tx_ring[i].data)) {
350 device_printf(dev, "unable to allocate ring buffers\n");
352 if (sc->rx_ring[i].data)
353 free(sc->rx_ring[i].data, M_DEVBUF);
354 if (sc->tx_ring[i].data)
355 free(sc->tx_ring[i].data, M_DEVBUF);
363 * Allocate interrupt and DMA channel
366 sc->oltr_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
367 (sc->config.mode & TRLLD_MODE_SHARE_INTERRUPT ? RF_ACTIVE | RF_SHAREABLE : RF_ACTIVE));
368 if (sc->oltr_irq == NULL) {
369 device_printf(dev, "couldn't map interrupt\n");
372 if (bus_setup_intr(dev, sc->oltr_irq, INTR_TYPE_NET, oltr_intr, sc, &sc->oltr_intrhand)) {
373 device_printf(dev, "couldn't setup interrupt\n");
374 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->oltr_irq);
379 * Do the ifnet initialization
382 if_initname(ifp, "oltr", device_get_unit(dev));
383 ifp->if_init = oltr_init;
384 ifp->if_start = oltr_start;
385 ifp->if_ioctl = oltr_ioctl;
386 ifp->if_flags = IFF_BROADCAST;
387 bcopy(sc->config.macaddress, sc->arpcom.ac_enaddr, sizeof(sc->config.macaddress));
392 ifmedia_init(&sc->ifmedia, 0, oltr_ifmedia_upd, oltr_ifmedia_sts);
393 rc = TRlldSetSpeed(sc->TRlldAdapter, TRLLD_SPEED_16MBPS);
394 switch(sc->config.type) {
395 case TRLLD_ADAPTER_PCI7: /* OC-3540 */
396 ifmedia_add(&sc->ifmedia, IFM_TOKEN|IFM_TOK_UTP100, 0, NULL);
398 case TRLLD_ADAPTER_PCI4: /* OC-3139 */
399 case TRLLD_ADAPTER_PCI5: /* OC-3140 */
400 case TRLLD_ADAPTER_PCI6: /* OC-3141 */
401 ifmedia_add(&sc->ifmedia, IFM_TOKEN|IFM_AUTO, 0, NULL);
402 media = IFM_TOKEN|IFM_AUTO;
403 rc = TRlldSetSpeed(sc->TRlldAdapter, 0);
406 ifmedia_add(&sc->ifmedia, IFM_TOKEN|IFM_TOK_UTP4, 0, NULL);
407 ifmedia_add(&sc->ifmedia, IFM_TOKEN|IFM_TOK_UTP16, 0, NULL);
410 sc->ifmedia.ifm_media = media;
411 ifmedia_set(&sc->ifmedia, media);
414 * Attach the interface
416 ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
417 iso88025_ifattach(ifp);
429 oltr_pci_detach(device_t dev)
431 struct oltr_softc *sc = device_get_softc(dev);
432 struct ifnet *ifp = &sc->arpcom.ac_if;
435 device_printf(dev, "driver unloading\n");
440 if (sc->state > OL_CLOSED)
443 untimeout(oltr_poll, (void *)sc, sc->oltr_poll_ch);
444 /*untimeout(oltr_stat, (void *)sc, sc->oltr_stat_ch);*/
446 bus_teardown_intr(dev, sc->oltr_irq, sc->oltr_intrhand);
447 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->oltr_irq);
449 /* Deallocate all dynamic memory regions */
450 for (i = 0; i < RING_BUFFER_LEN; i++) {
451 free(sc->rx_ring[i].data, M_DEVBUF);
452 free(sc->tx_ring[i].data, M_DEVBUF);
455 free(sc->work_memory, M_DEVBUF);
456 free(sc->TRlldAdapter, M_DEVBUF);
464 oltr_pci_shutdown(device_t dev)
466 struct oltr_softc *sc = device_get_softc(dev);
468 device_printf(dev, "oltr_pci_shutdown called\n");
470 if (sc->state > OL_CLOSED)
478 static const char *oltr_pci_probe (pcici_t, pcidi_t);
479 static void oltr_pci_attach (pcici_t, int);
481 static unsigned long oltr_count = 0;
483 static struct pci_device oltr_device = {
491 DATA_SET(pcidevice_set, oltr_device);
494 oltr_pci_probe(pcici_t config_id, pcidi_t device_id)
497 char PCIConfigHeader[64];
498 TRlldAdapterConfig_t config;
500 if (((device_id & 0xffff) == PCI_VENDOR_OLICOM) && (
501 (((device_id >> 16) & 0xffff) == 0x0001) ||
502 (((device_id >> 16) & 0xffff) == 0x0004) ||
503 (((device_id >> 16) & 0xffff) == 0x0005) ||
504 (((device_id >> 16) & 0xffff) == 0x0007) ||
505 (((device_id >> 16) & 0xffff) == 0x0008))) {
507 for (i = 0; i < 64; i++)
508 PCIConfigHeader[i] = pci_cfgread(config_id, i, /* bytes */ 1);
510 rc = TRlldPCIConfig(&LldDriver, &config, PCIConfigHeader);
512 if (rc == TRLLD_PCICONFIG_FAIL) {
513 printf("oltr: TRlldPciConfig failed!\n");
516 if (rc == TRLLD_PCICONFIG_VERSION) {
517 printf("oltr: wrong LLD version.\n");
520 return(AdapterName[config.type]);
527 oltr_pci_attach(pcici_t config_id, int unit)
529 int i, s, rc = 0, scratch_size;
530 int media = IFM_TOKEN|IFM_TOK_UTP16;
532 char PCIConfigHeader[64];
533 struct oltr_softc *sc;
534 struct ifnet *ifp; /* = &sc->arpcom.ac_if; */
538 sc = malloc(sizeof(struct oltr_softc), M_DEVBUF, M_NOWAIT | M_ZERO);
540 printf("oltr%d: no memory for softc struct!\n", unit);
544 sc->state = OL_UNKNOWN;
545 ifp = &sc->arpcom.ac_if;
547 for (i = 0; i < sizeof(PCIConfigHeader); i++)
548 PCIConfigHeader[i] = pci_cfgread(config_id, i, 1);
550 switch(TRlldPCIConfig(&LldDriver, &sc->config, PCIConfigHeader)) {
551 case TRLLD_PCICONFIG_OK:
553 case TRLLD_PCICONFIG_SET_COMMAND:
554 printf("oltr%d: enabling bus master mode\n", unit);
555 command = pci_conf_read(config_id, PCIR_COMMAND);
556 pci_conf_write(config_id, PCIR_COMMAND, (command | PCIM_CMD_BUSMASTEREN));
557 command = pci_conf_read(config_id, PCIR_COMMAND);
558 if (!(command & PCIM_CMD_BUSMASTEREN)) {
559 printf("oltr%d: failed to enable bus master mode\n", unit);
563 case TRLLD_PCICONFIG_FAIL:
564 printf("oltr%d: TRlldPciConfig failed!\n", unit);
567 case TRLLD_PCICONFIG_VERSION:
568 printf("oltr%d: wrong LLD version\n", unit);
572 printf("oltr%d: MAC address %6D\n", unit, sc->config.macaddress, ":");
574 scratch_size = TRlldAdapterSize();
576 printf("oltr%d: adapter memory block size %d bytes\n", unit, scratch_size);
577 sc->TRlldAdapter = (TRlldAdapter_t)malloc(scratch_size, M_DEVBUF, M_NOWAIT);
578 if (sc->TRlldAdapter == NULL) {
579 printf("oltr%d: couldn't allocate scratch buffer (%d bytes)\n",unit, scratch_size);
584 * Allocate RX/TX Pools
586 for (i = 0; i < RING_BUFFER_LEN; i++) {
587 sc->rx_ring[i].index = i;
588 sc->rx_ring[i].data = (char *)malloc(RX_BUFFER_LEN, M_DEVBUF, M_NOWAIT);
589 sc->rx_ring[i].address = vtophys(sc->rx_ring[i].data);
590 sc->tx_ring[i].index = i;
591 sc->tx_ring[i].data = (char *)malloc(TX_BUFFER_LEN, M_DEVBUF, M_NOWAIT);
592 sc->tx_ring[i].address = vtophys(sc->tx_ring[i].data);
593 if ((!sc->rx_ring[i].data) || (!sc->tx_ring[i].data)) {
594 printf("oltr%d: unable to allocate ring buffers\n", unit);
596 if (sc->rx_ring[i].data)
597 free(sc->rx_ring[i].data, M_DEVBUF);
598 if (sc->tx_ring[i].data)
599 free(sc->tx_ring[i].data, M_DEVBUF);
607 * Allocate interrupt and DMA channel
609 if (!pci_map_int(config_id, oltr_intr, sc, &net_imask)) {
610 printf("oltr%d: couldn't setup interrupt\n", unit);
615 * Do the ifnet initialization
618 if_initname(ifp, "oltr", unit);
619 ifp->if_output = iso88025_output;
620 ifp->if_init = oltr_init;
621 ifp->if_start = oltr_start;
622 ifp->if_ioctl = oltr_ioctl;
623 ifp->if_flags = IFF_BROADCAST;
624 bcopy(sc->config.macaddress, sc->arpcom.ac_enaddr, sizeof(sc->config.macaddress));
629 ifmedia_init(&sc->ifmedia, 0, oltr_ifmedia_upd, oltr_ifmedia_sts);
630 rc = TRlldSetSpeed(sc->TRlldAdapter, TRLLD_SPEED_16MBPS);
631 switch(sc->config.type) {
632 case TRLLD_ADAPTER_PCI7: /* OC-3540 */
633 ifmedia_add(&sc->ifmedia, IFM_TOKEN|IFM_TOK_UTP100, 0, NULL);
635 case TRLLD_ADAPTER_PCI4: /* OC-3139 */
636 case TRLLD_ADAPTER_PCI5: /* OC-3140 */
637 case TRLLD_ADAPTER_PCI6: /* OC-3141 */
638 ifmedia_add(&sc->ifmedia, IFM_TOKEN|IFM_AUTO, 0, NULL);
639 media = IFM_TOKEN|IFM_AUTO;
640 rc = TRlldSetSpeed(sc->TRlldAdapter, 0);
643 ifmedia_add(&sc->ifmedia, IFM_TOKEN|IFM_TOK_UTP4, 0, NULL);
644 ifmedia_add(&sc->ifmedia, IFM_TOKEN|IFM_TOK_UTP16, 0, NULL);
647 sc->ifmedia.ifm_media = media;
648 ifmedia_set(&sc->ifmedia, media);
651 * Attach the interface
653 ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
654 iso88025_ifattach(ifp);
670 struct oltr_softc *sc = (struct oltr_softc *)xsc;
672 if (DEBUG_MASK & DEBUG_INT)
675 TRlldInterruptService(sc->TRlldAdapter);
681 oltr_start(struct ifnet *ifp)
683 struct oltr_softc *sc = ifp->if_softc;
685 int copy_len, buffer, frame, fragment, rc, s;
688 * Check to see if output is already active
690 if (ifp->if_flags & IFF_OACTIVE)
696 * Make sure we have buffers to transmit with
698 if (sc->tx_avail <= 0) {
699 printf("oltr%d: tx queue full\n", sc->unit);
700 ifp->if_flags |= IFF_OACTIVE;
704 if (sc->restart == NULL) {
705 IF_DEQUEUE(&ifp->if_snd, m);
714 frame = RING_BUFFER(sc->tx_frame);
715 buffer = RING_BUFFER(sc->tx_head);
718 sc->frame_ring[frame].FragmentCount = 0;
720 while (copy_len < m0->m_pkthdr.len) {
721 sc->frame_ring[frame].FragmentCount++;
722 if (sc->frame_ring[frame].FragmentCount > sc->tx_avail)
724 sc->frame_ring[frame].TransmitFragment[fragment].VirtualAddress = sc->tx_ring[buffer].data;
725 sc->frame_ring[frame].TransmitFragment[fragment].PhysicalAddress = sc->tx_ring[buffer].address;
726 sc->frame_ring[frame].TransmitFragment[fragment].count = MIN(m0->m_pkthdr.len - copy_len, TX_BUFFER_LEN);
727 m_copydata(m0, copy_len, MIN(m0->m_pkthdr.len - copy_len, TX_BUFFER_LEN), sc->tx_ring[buffer].data);
728 copy_len += MIN(m0->m_pkthdr.len - copy_len, TX_BUFFER_LEN);
730 buffer = RING_BUFFER((buffer + 1));
734 rc = TRlldTransmitFrame(sc->TRlldAdapter, &sc->frame_ring[frame], (void *)&sc->frame_ring[frame]);
737 if (rc != TRLLD_TRANSMIT_OK) {
738 printf("oltr%d: TRlldTransmitFrame returned %d\n", sc->unit, rc);
743 sc->tx_avail -= sc->frame_ring[frame].FragmentCount;
744 sc->tx_head = RING_BUFFER((sc->tx_head + sc->frame_ring[frame].FragmentCount));
747 #if (NBPFILTER > 0) || defined(__DragonFly__) || (__FreeBSD_version > 400000)
751 /*ifp->if_opackets++;*/
760 printf("oltr%d: queue full\n", sc->unit);
761 ifp->if_flags |= IFF_OACTIVE;
770 oltr_close(struct oltr_softc *sc)
772 /*printf("oltr%d: oltr_close\n", sc->unit);*/
776 tsleep(sc, 0, "oltrclose", 30*hz);
780 oltr_stop(struct oltr_softc *sc)
782 struct ifnet *ifp = &sc->arpcom.ac_if;
784 /*printf("oltr%d: oltr_stop\n", sc->unit);*/
786 ifp->if_flags &= ~(IFF_UP | IFF_RUNNING | IFF_OACTIVE);
787 TRlldClose(sc->TRlldAdapter, 0);
788 sc->state = OL_CLOSING;
792 oltr_init(void * xsc)
794 struct oltr_softc *sc = (struct oltr_softc *)xsc;
795 struct ifnet *ifp = &sc->arpcom.ac_if;
796 struct ifmedia *ifm = &sc->ifmedia;
797 int poll = 0, i, rc = 0, s;
801 * Check adapter state, don't allow multiple inits
803 if (sc->state > OL_CLOSED) {
804 printf("oltr%d: adapter not ready\n", sc->unit);
813 if ((rc = TRlldAdapterInit(&LldDriver, sc->TRlldAdapter, vtophys(sc->TRlldAdapter),
814 (void *)sc, &sc->config)) != TRLLD_INIT_OK) {
816 case TRLLD_INIT_NOT_FOUND:
817 printf("oltr%d: adapter not found\n", sc->unit);
819 case TRLLD_INIT_UNSUPPORTED:
820 printf("oltr%d: adapter not supported by low level driver\n", sc->unit);
822 case TRLLD_INIT_PHYS16:
823 printf("oltr%d: adapter memory block above 16M cannot DMA\n", sc->unit);
825 case TRLLD_INIT_VERSION:
826 printf("oltr%d: low level driver version mismatch\n", sc->unit);
829 printf("oltr%d: unknown init error %d\n", sc->unit, rc);
836 switch(sc->config.type) {
837 case TRLLD_ADAPTER_PCI4: /* OC-3139 */
838 work_size = 32 * 1024;
840 case TRLLD_ADAPTER_PCI7: /* OC-3540 */
848 if ((sc->work_memory = malloc(work_size, M_DEVBUF, M_NOWAIT)) == NULL) {
849 printf("oltr%d: failed to allocate work memory (%d octets).\n", sc->unit, work_size);
851 TRlldAddMemory(sc->TRlldAdapter, sc->work_memory,
852 vtophys(sc->work_memory), work_size);
856 switch(IFM_SUBTYPE(ifm->ifm_media)) {
858 rc = TRlldSetSpeed(sc->TRlldAdapter, 0); /* TRLLD_SPEED_AUTO */
861 rc = TRlldSetSpeed(sc->TRlldAdapter, TRLLD_SPEED_4MBPS);
864 rc = TRlldSetSpeed(sc->TRlldAdapter, TRLLD_SPEED_16MBPS);
867 rc = TRlldSetSpeed(sc->TRlldAdapter, TRLLD_SPEED_100MBPS);
872 * Download adapter micro-code
875 printf("oltr%d: Downloading adapter microcode: ", sc->unit);
877 switch(sc->config.mactype) {
879 rc = TRlldDownload(sc->TRlldAdapter, TRlldMacCode);
883 case TRLLD_MAC_HAWKEYE:
884 rc = TRlldDownload(sc->TRlldAdapter, TRlldHawkeyeMac);
888 case TRLLD_MAC_BULLSEYE:
889 rc = TRlldDownload(sc->TRlldAdapter, TRlldBullseyeMac);
895 printf("unknown - failed!\n");
901 * Check download status
904 case TRLLD_DOWNLOAD_OK:
908 case TRLLD_DOWNLOAD_ERROR:
910 printf(" - failed\n");
912 printf("oltr%d: adapter microcode download failed\n", sc->unit);
917 printf(" - not ready\n");
923 * Wait for self-test to complete
926 while ((poll++ < SELF_TEST_POLLS) && (sc->state < OL_READY)) {
927 if (DEBUG_MASK & DEBUG_INIT)
929 DELAY(TRlldPoll(sc->TRlldAdapter) * 1000);
930 if (TRlldInterruptService(sc->TRlldAdapter) != 0)
931 if (DEBUG_MASK & DEBUG_INIT) printf("i");
934 if (sc->state != OL_CLOSED) {
935 printf("oltr%d: self-test failed\n", sc->unit);
940 * Set up adapter poll
942 callout_handle_init(&sc->oltr_poll_ch);
943 sc->oltr_poll_ch = timeout(oltr_poll, (void *)sc, 1);
945 sc->state = OL_OPENING;
950 rc = TRlldOpen(sc->TRlldAdapter, sc->arpcom.ac_enaddr, sc->GroupAddress,
951 sc->FunctionalAddress, 1552, sc->AdapterMode);
955 case TRLLD_OPEN_STATE:
956 printf("oltr%d: adapter not ready for open\n", sc->unit);
959 case TRLLD_OPEN_ADDRESS_ERROR:
960 printf("oltr%d: illegal MAC address\n", sc->unit);
963 case TRLLD_OPEN_MODE_ERROR:
964 printf("oltr%d: illegal open mode\n", sc->unit);
968 printf("oltr%d: unknown open error (%d)\n", sc->unit, rc);
974 * Set promiscious mode for now...
976 TRlldSetPromiscuousMode(sc->TRlldAdapter, TRLLD_PROM_LLC);
977 ifp->if_flags |= IFF_PROMISC;
980 * Block on the ring insert and set a timeout
982 tsleep(sc, 0, "oltropen", 30*hz);
985 * Set up receive buffer ring
987 for (i = 0; i < RING_BUFFER_LEN; i++) {
988 rc = TRlldReceiveFragment(sc->TRlldAdapter, (void *)sc->rx_ring[i].data,
989 sc->rx_ring[i].address, RX_BUFFER_LEN, (void *)sc->rx_ring[i].index);
990 if (rc != TRLLD_RECEIVE_OK) {
991 printf("oltr%d: adapter refused receive fragment %d (rc = %d)\n", sc->unit, i, rc);
996 sc->tx_avail = RING_BUFFER_LEN;
1002 ifp->if_flags |= IFF_RUNNING;
1003 ifp->if_flags &= ~IFF_OACTIVE;
1006 * Set up adapter statistics poll
1008 /*callout_handle_init(&sc->oltr_stat_ch);*/
1009 /*sc->oltr_stat_ch = timeout(oltr_stat, (void *)sc, 1*hz);*/
1015 sc->state = OL_DEAD;
1021 oltr_ioctl(struct ifnet *ifp, u_long command, caddr_t data, struct ucred *cr)
1023 struct oltr_softc *sc = ifp->if_softc;
1024 struct ifreq *ifr = (struct ifreq *)data;
1033 error = iso88025_ioctl(ifp, command, data);
1037 if (ifp->if_flags & IFF_UP) {
1040 if (ifp->if_flags & IFF_RUNNING) {
1047 error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, command);
1061 oltr_poll(void *arg)
1063 struct oltr_softc *sc = (struct oltr_softc *)arg;
1068 if (DEBUG_MASK & DEBUG_POLL) printf("P");
1070 /* Set up next adapter poll */
1071 sc->oltr_poll_ch = timeout(oltr_poll, (void *)sc, (TRlldPoll(sc->TRlldAdapter) * hz / 1000));
1078 oltr_stat(void *arg)
1080 struct oltr_softc *sc = (struct oltr_softc *)arg;
1085 /* Set up next adapter poll */
1086 sc->oltr_stat_ch = timeout(oltr_stat, (void *)sc, 1*hz);
1087 if (TRlldGetStatistics(sc->TRlldAdapter, &sc->current, 0) != 0) {
1088 /*printf("oltr%d: statistics available immediately...\n", sc->unit);*/
1089 DriverStatistics((void *)sc, &sc->current);
1096 oltr_ifmedia_upd(struct ifnet *ifp)
1098 struct oltr_softc *sc = ifp->if_softc;
1099 struct ifmedia *ifm = &sc->ifmedia;
1102 if (IFM_TYPE(ifm->ifm_media) != IFM_TOKEN)
1105 switch(IFM_SUBTYPE(ifm->ifm_media)) {
1107 rc = TRlldSetSpeed(sc->TRlldAdapter, 0); /* TRLLD_SPEED_AUTO */
1110 rc = TRlldSetSpeed(sc->TRlldAdapter, TRLLD_SPEED_4MBPS);
1113 rc = TRlldSetSpeed(sc->TRlldAdapter, TRLLD_SPEED_16MBPS);
1115 case IFM_TOK_UTP100:
1116 rc = TRlldSetSpeed(sc->TRlldAdapter, TRLLD_SPEED_100MBPS);
1128 oltr_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
1130 struct oltr_softc *sc = ifp->if_softc;
1131 struct ifmedia *ifm = &sc->ifmedia;
1133 /*printf("oltr%d: oltr_ifmedia_sts\n", sc->unit);*/
1135 ifmr->ifm_active = IFM_TYPE(ifm->ifm_media)|IFM_SUBTYPE(ifm->ifm_media);
1140 * ---------------------- PMW Callback Functions -----------------------
1144 DriverStatistics(void *DriverHandle, TRlldStatistics_t *statistics)
1147 struct oltr_softc *sc = (struct oltr_softc *)DriverHandle;
1149 if (sc->statistics.LineErrors != statistics->LineErrors)
1150 printf("oltr%d: Line Errors %lu\n", sc->unit,
1151 statistics->LineErrors);
1152 if (sc->statistics.InternalErrors != statistics->InternalErrors)
1153 printf("oltr%d: Internal Errors %lu\n", sc->unit,
1154 statistics->InternalErrors);
1155 if (sc->statistics.BurstErrors != statistics->BurstErrors)
1156 printf("oltr%d: Burst Errors %lu\n", sc->unit,
1157 statistics->BurstErrors);
1158 if (sc->statistics.AbortDelimiters != statistics->AbortDelimiters)
1159 printf("oltr%d: Abort Delimiters %lu\n", sc->unit,
1160 statistics->AbortDelimiters);
1161 if (sc->statistics.ARIFCIErrors != statistics->ARIFCIErrors)
1162 printf("oltr%d: ARIFCI Errors %lu\n", sc->unit,
1163 statistics->ARIFCIErrors);
1164 if (sc->statistics.LostFrames != statistics->LostFrames)
1165 printf("oltr%d: Lost Frames %lu\n", sc->unit,
1166 statistics->LostFrames);
1167 if (sc->statistics.CongestionErrors != statistics->CongestionErrors)
1168 printf("oltr%d: Congestion Errors %lu\n", sc->unit,
1169 statistics->CongestionErrors);
1170 if (sc->statistics.FrequencyErrors != statistics->FrequencyErrors)
1171 printf("oltr%d: Frequency Errors %lu\n", sc->unit,
1172 statistics->FrequencyErrors);
1173 if (sc->statistics.TokenErrors != statistics->TokenErrors)
1174 printf("oltr%d: Token Errors %lu\n", sc->unit,
1175 statistics->TokenErrors);
1176 if (sc->statistics.DMABusErrors != statistics->DMABusErrors)
1177 printf("oltr%d: DMA Bus Errors %lu\n", sc->unit,
1178 statistics->DMABusErrors);
1179 if (sc->statistics.DMAParityErrors != statistics->DMAParityErrors)
1180 printf("oltr%d: DMA Parity Errors %lu\n", sc->unit,
1181 statistics->DMAParityErrors);
1182 if (sc->statistics.ReceiveLongFrame != statistics->ReceiveLongFrame)
1183 printf("oltr%d: Long frames received %lu\n", sc->unit,
1184 statistics->ReceiveLongFrame);
1185 if (sc->statistics.ReceiveCRCErrors != statistics->ReceiveCRCErrors)
1186 printf("oltr%d: Receive CRC Errors %lu\n", sc->unit,
1187 statistics->ReceiveCRCErrors);
1188 if (sc->statistics.ReceiveOverflow != statistics->ReceiveOverflow)
1189 printf("oltr%d: Recieve overflows %lu\n", sc->unit,
1190 statistics->ReceiveOverflow);
1191 if (sc->statistics.TransmitUnderrun != statistics->TransmitUnderrun)
1192 printf("oltr%d: Frequency Errors %lu\n", sc->unit,
1193 statistics->TransmitUnderrun);
1194 bcopy(statistics, &sc->statistics, sizeof(TRlldStatistics_t));
1199 DriverSuspend(unsigned short MicroSeconds)
1201 DELAY(MicroSeconds);
1206 DriverStatus(void *DriverHandle, TRlldStatus_t *Status)
1208 struct oltr_softc *sc = (struct oltr_softc *)DriverHandle;
1209 struct ifnet *ifp = &sc->arpcom.ac_if;
1211 char *Protocol[] = { /* 0 */ "Unknown",
1214 char *Timeout[] = { /* 0 */ "command",
1216 /* 2 */ "interrupt" };
1218 switch (Status->Type) {
1220 case TRLLD_STS_ON_WIRE:
1221 printf("oltr%d: ring insert (%d Mbps - %s)\n", sc->unit,
1222 Status->Specification.OnWireInformation.Speed,
1223 Protocol[Status->Specification.OnWireInformation.AccessProtocol]);
1224 sc->state = OL_OPEN;
1227 case TRLLD_STS_SELFTEST_STATUS:
1228 if (Status->Specification.SelftestStatus == TRLLD_ST_OK) {
1229 sc->state = OL_CLOSED;
1231 printf("oltr%d: self test complete\n", sc->unit);
1233 if (Status->Specification.SelftestStatus & TRLLD_ST_ERROR) {
1234 printf("oltr%d: Adapter self test error %d", sc->unit,
1235 Status->Specification.SelftestStatus & ~TRLLD_ST_ERROR);
1236 sc->state = OL_DEAD;
1238 if (Status->Specification.SelftestStatus & TRLLD_ST_TIMEOUT) {
1239 printf("oltr%d: Adapter self test timed out.\n", sc->unit);
1240 sc->state = OL_DEAD;
1243 case TRLLD_STS_INIT_STATUS:
1244 if (Status->Specification.InitStatus == 0x800) {
1246 ifmedia_set(&sc->ifmedia, IFM_TOKEN|IFM_TOK_UTP16);
1247 TRlldSetSpeed(sc->TRlldAdapter, TRLLD_SPEED_16MBPS);
1251 printf("oltr%d: adapter init failure 0x%03x\n", sc->unit,
1252 Status->Specification.InitStatus);
1255 case TRLLD_STS_RING_STATUS:
1256 if (Status->Specification.RingStatus) {
1257 printf("oltr%d: Ring status change: ", sc->unit);
1258 if (Status->Specification.RingStatus &
1259 TRLLD_RS_SIGNAL_LOSS)
1260 printf(" [Signal Loss]");
1261 if (Status->Specification.RingStatus &
1262 TRLLD_RS_HARD_ERROR)
1263 printf(" [Hard Error]");
1264 if (Status->Specification.RingStatus &
1265 TRLLD_RS_SOFT_ERROR)
1266 printf(" [Soft Error]");
1267 if (Status->Specification.RingStatus &
1268 TRLLD_RS_TRANSMIT_BEACON)
1269 printf(" [Beacon]");
1270 if (Status->Specification.RingStatus &
1271 TRLLD_RS_LOBE_WIRE_FAULT)
1272 printf(" [Wire Fault]");
1273 if (Status->Specification.RingStatus &
1274 TRLLD_RS_AUTO_REMOVAL_ERROR)
1275 printf(" [Auto Removal]");
1276 if (Status->Specification.RingStatus &
1277 TRLLD_RS_REMOVE_RECEIVED)
1278 printf(" [Remove Received]");
1279 if (Status->Specification.RingStatus &
1280 TRLLD_RS_COUNTER_OVERFLOW)
1281 printf(" [Counter Overflow]");
1282 if (Status->Specification.RingStatus &
1283 TRLLD_RS_SINGLE_STATION)
1284 printf(" [Single Station]");
1285 if (Status->Specification.RingStatus &
1286 TRLLD_RS_RING_RECOVERY)
1287 printf(" [Ring Recovery]");
1291 case TRLLD_STS_ADAPTER_CHECK:
1292 printf("oltr%d: adapter check (%04x %04x %04x %04x)\n", sc->unit,
1293 Status->Specification.AdapterCheck[0],
1294 Status->Specification.AdapterCheck[1],
1295 Status->Specification.AdapterCheck[2],
1296 Status->Specification.AdapterCheck[3]);
1297 sc->state = OL_DEAD;
1300 case TRLLD_STS_PROMISCUOUS_STOPPED:
1301 printf("oltr%d: promiscuous mode ", sc->unit);
1302 if (Status->Specification.PromRemovedCause == 1)
1303 printf("remove received.");
1304 if (Status->Specification.PromRemovedCause == 2)
1305 printf("poll failure.");
1306 if (Status->Specification.PromRemovedCause == 2)
1307 printf("buffer size failure.");
1309 ifp->if_flags &= ~IFF_PROMISC;
1311 case TRLLD_STS_LLD_ERROR:
1312 printf("oltr%d: low level driver internal error ", sc->unit);
1313 printf("(%04x %04x %04x %04x).\n",
1314 Status->Specification.InternalError[0],
1315 Status->Specification.InternalError[1],
1316 Status->Specification.InternalError[2],
1317 Status->Specification.InternalError[3]);
1318 sc->state = OL_DEAD;
1321 case TRLLD_STS_ADAPTER_TIMEOUT:
1322 printf("oltr%d: adapter %s timeout.\n", sc->unit,
1323 Timeout[Status->Specification.AdapterTimeout]);
1326 printf("oltr%d: driver status Type = %d\n", sc->unit, Status->Type);
1330 if (Status->Closed) {
1331 sc->state = OL_CLOSING;
1338 DriverCloseCompleted(void *DriverHandle)
1340 struct oltr_softc *sc = (struct oltr_softc *)DriverHandle;
1342 printf("oltr%d: adapter closed\n", sc->unit);
1344 sc->state = OL_CLOSED;
1348 DriverTransmitFrameCompleted(void *DriverHandle, void *FrameHandle, int TransmitStatus)
1350 struct oltr_softc *sc = (struct oltr_softc *)DriverHandle;
1351 struct ifnet *ifp = &sc->arpcom.ac_if;
1352 TRlldTransmit_t *frame = (TRlldTransmit_t *)FrameHandle;
1354 /*printf("oltr%d: DriverTransmitFrameCompleted\n", sc->unit);*/
1356 if (TransmitStatus != TRLLD_TRANSMIT_OK) {
1358 printf("oltr%d: transmit error %d\n", sc->unit, TransmitStatus);
1363 sc->tx_avail += frame->FragmentCount;
1365 if (ifp->if_flags & IFF_OACTIVE) {
1366 printf("oltr%d: queue restart\n", sc->unit);
1367 ifp->if_flags &= ~IFF_OACTIVE;
1375 DriverReceiveFrameCompleted(void *DriverHandle, int ByteCount, int FragmentCount, void *FragmentHandle, int ReceiveStatus)
1377 struct oltr_softc *sc = (struct oltr_softc *)DriverHandle;
1378 struct ifnet *ifp = (struct ifnet *)&sc->arpcom.ac_if;
1379 struct mbuf *m0, *m1, *m;
1380 struct iso88025_header *th;
1381 int frame_len = ByteCount, i = (int)FragmentHandle, rc, s;
1382 int mbuf_offset, mbuf_size, frag_offset, copy_length;
1383 char *fragment = sc->rx_ring[RING_BUFFER(i)].data;
1385 if (sc->state > OL_CLOSED) {
1386 if (ReceiveStatus == TRLLD_RCV_OK) {
1387 MGETHDR(m0, MB_DONTWAIT, MT_DATA);
1388 mbuf_size = MHLEN - 2;
1393 if (ByteCount + 2 > MHLEN) {
1394 MCLGET(m0, MB_DONTWAIT);
1395 mbuf_size = MCLBYTES - 2;
1396 if (!(m0->m_flags & M_EXT)) {
1402 m0->m_pkthdr.rcvif = ifp;
1403 m0->m_pkthdr.len = ByteCount;
1406 th = mtod(m0, struct iso88025_header *);
1407 m0->m_pkthdr.header = (void *)th;
1413 copy_length = MIN3(frame_len,
1414 (RX_BUFFER_LEN - frag_offset),
1415 (mbuf_size - mbuf_offset));
1416 bcopy(fragment + frag_offset, mtod(m, char *) +
1417 mbuf_offset, copy_length);
1418 m->m_len += copy_length;
1419 mbuf_offset += copy_length;
1420 frag_offset += copy_length;
1421 frame_len -= copy_length;
1423 if (frag_offset == RX_BUFFER_LEN) {
1425 sc->rx_ring[RING_BUFFER(++i)].data;
1428 if ((mbuf_offset == mbuf_size) && (frame_len > 0)) {
1429 MGET(m1, MB_DONTWAIT, MT_DATA);
1436 if (frame_len > MHLEN) {
1437 MCLGET(m1, MB_DONTWAIT);
1438 mbuf_size = MCLBYTES;
1439 if (!(m1->m_flags & M_EXT)) {
1452 #if (NBPFILTER > 0) || defined(__DragonFly__) || (__FreeBSD_version > 400000)
1457 /*if (ifp->if_flags & IFF_PROMISC) {*/
1458 if (bcmp(th->iso88025_dhost, ifp->if_broadcastaddr,
1460 if ((bcmp(th->iso88025_dhost + 1, sc->arpcom.ac_enaddr + 1, ISO88025_ADDR_LEN - 1)) ||
1461 ((th->iso88025_dhost[0] & 0x7f) != sc->arpcom.ac_enaddr[0])) {
1469 (*ifp->if_input)(ifp, m0);
1471 } else { /* Receiver error */
1472 if (ReceiveStatus != TRLLD_RCV_NO_DATA) {
1473 printf("oltr%d: receive error %d\n", sc->unit,
1481 i = (int)FragmentHandle;
1482 while (FragmentCount--) {
1483 rc = TRlldReceiveFragment(sc->TRlldAdapter,
1484 (void *)sc->rx_ring[RING_BUFFER(i)].data,
1485 sc->rx_ring[RING_BUFFER(i)].address,
1486 RX_BUFFER_LEN, (void *)sc->rx_ring[RING_BUFFER(i)].index);
1487 if (rc != TRLLD_RECEIVE_OK) {
1488 printf("oltr%d: adapter refused receive fragment %d (rc = %d)\n", sc->unit, i, rc);
1499 * ---------------------------- PMW Glue -------------------------------
1502 #ifndef TRlldInlineIO
1505 DriverOutByte(unsigned short IOAddress, unsigned char value)
1507 outb(IOAddress, value);
1511 DriverOutWord(unsigned short IOAddress, unsigned short value)
1513 outw(IOAddress, value);
1517 DriverOutDword(unsigned short IOAddress, unsigned long value)
1519 outl(IOAddress, value);
1523 DriverRepOutByte(unsigned short IOAddress, unsigned char *DataPointer, int ByteCount)
1525 outsb(IOAddress, (void *)DataPointer, ByteCount);
1529 DriverRepOutWord(unsigned short IOAddress, unsigned short *DataPointer, int WordCount)
1531 outsw(IOAddress, (void *)DataPointer, WordCount);
1535 DriverRepOutDword(unsigned short IOAddress, unsigned long *DataPointer, int DWordCount)
1537 outsl(IOAddress, (void *)DataPointer, DWordCount);
1540 static unsigned char
1541 DriverInByte(unsigned short IOAddress)
1543 return(inb(IOAddress));
1546 static unsigned short
1547 DriverInWord(unsigned short IOAddress)
1549 return(inw(IOAddress));
1552 static unsigned long
1553 DriverInDword(unsigned short IOAddress)
1555 return(inl(IOAddress));
1559 DriverRepInByte(unsigned short IOAddress, unsigned char *DataPointer, int ByteCount)
1561 insb(IOAddress, (void *)DataPointer, ByteCount);
1565 DriverRepInWord(unsigned short IOAddress, unsigned short *DataPointer, int WordCount)
1567 insw(IOAddress, (void *)DataPointer, WordCount);
1570 DriverRepInDword( unsigned short IOAddress, unsigned long *DataPointer, int DWordCount)
1572 insl(IOAddress, (void *)DataPointer, DWordCount);
1574 #endif /* TRlldInlineIO */