?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Set framelen to 0; it might be used without being initialized
[dfdiff.git] / sys / dev / netif / sbni / if_sbni.c
blobd6f55b7052170aacf61e114e7a49b1d1ea5fb68d
1 /*
2 * Copyright (c) 1997-2001 Granch, Ltd. All rights reserved.
3 * Author: Denis I.Timofeev <timofeev@granch.ru>
4 *
5 * Redistributon 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 unmodified, this list of conditions, and the following
10 * disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD: src/sys/dev/sbni/if_sbni.c,v 1.1.2.4 2002/08/11 09:32:00 fjoe Exp $
28 * $DragonFly: src/sys/dev/netif/sbni/if_sbni.c,v 1.27 2008/03/10 08:36:30 sephe Exp $
29 */
30
31 /*
32 * Device driver for Granch SBNI12 leased line adapters
33 *
34 * Revision 2.0.0 1997/08/06
35 * Initial revision by Alexey Zverev
36 *
37 * Revision 2.0.1 1997/08/11
38 * Additional internal statistics support (tx statistics)
39 *
40 * Revision 2.0.2 1997/11/05
41 * if_bpf bug has been fixed
42 *
43 * Revision 2.0.3 1998/12/20
44 * Memory leakage has been eliminated in
45 * the sbni_st and sbni_timeout routines.
46 *
47 * Revision 3.0 2000/08/10 by Yaroslav Polyakov
48 * Support for PCI cards. 4.1 modification.
49 *
50 * Revision 3.1 2000/09/12
51 * Removed extra #defines around bpf functions
52 *
53 * Revision 4.0 2000/11/23 by Denis Timofeev
54 * Completely redesigned the buffer management
55 *
56 * Revision 4.1 2001/01/21
57 * Support for PCI Dual cards and new SBNI12D-10, -11 Dual/ISA cards
58 *
59 * Written with reference to NE2000 driver developed by David Greenman.
60 */
61
62
63 #include <sys/param.h>
64 #include <sys/systm.h>
65 #include <sys/socket.h>
66 #include <sys/sockio.h>
67 #include <sys/mbuf.h>
68 #include <sys/kernel.h>
69 #include <sys/proc.h>
70 #include <sys/callout.h>
71 #include <sys/syslog.h>
72 #include <sys/random.h>
73 #include <sys/bus.h>
74 #include <sys/rman.h>
75 #include <sys/thread2.h>
76
77 #include <net/if.h>
78 #include <net/ifq_var.h>
79 #include <net/ethernet.h>
80 #include <net/if_arp.h>
81 #include <net/bpf.h>
82
83 #include "if_sbnireg.h"
84 #include "if_sbnivar.h"
85
86 #ifdef __i386__
87 #define ASM_CRC 1
88 #endif
89
90 static void sbni_init(void *);
91 static void sbni_start(struct ifnet *);
92 static int sbni_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
93 static void sbni_watchdog(struct ifnet *);
94 static void sbni_stop(struct sbni_softc *);
95 static void handle_channel(struct sbni_softc *);
96
97 static void card_start(struct sbni_softc *);
98 static int recv_frame(struct sbni_softc *);
99 static void send_frame(struct sbni_softc *);
100 static int upload_data(struct sbni_softc *, u_int, u_int, u_int, u_int32_t);
101 static int skip_tail(struct sbni_softc *, u_int, u_int32_t);
102 static void interpret_ack(struct sbni_softc *, u_int);
103 static void download_data(struct sbni_softc *, u_int32_t *);
104 static void prepare_to_send(struct sbni_softc *);
105 static void drop_xmit_queue(struct sbni_softc *);
106 static int get_rx_buf(struct sbni_softc *);
107 static void indicate_pkt(struct sbni_softc *);
108 static void change_level(struct sbni_softc *);
109 static int check_fhdr(struct sbni_softc *, u_int *, u_int *,
110 u_int *, u_int *, u_int32_t *);
111 static int append_frame_to_pkt(struct sbni_softc *, u_int, u_int32_t);
112 static void timeout_change_level(struct sbni_softc *);
113 static void send_frame_header(struct sbni_softc *, u_int32_t *);
114 static void set_initial_values(struct sbni_softc *, struct sbni_flags);
115
116 static u_int32_t calc_crc32(u_int32_t, caddr_t, u_int);
117 static timeout_t sbni_timeout;
118
119 static __inline u_char sbni_inb(struct sbni_softc *, enum sbni_reg);
120 static __inline void sbni_outb(struct sbni_softc *, enum sbni_reg, u_char);
121 static __inline void sbni_insb(struct sbni_softc *, u_char *, u_int);
122 static __inline void sbni_outsb(struct sbni_softc *, u_char *, u_int);
123
124 DECLARE_DUMMY_MODULE(if_sbni);
125
126 static u_int32_t crc32tab[];
127
128 #ifdef SBNI_DUAL_COMPOUND
129 struct sbni_softc *sbni_headlist;
130 #endif
131
132 u_int32_t next_sbni_unit;
133
134 /* -------------------------------------------------------------------------- */
135
136 static __inline u_char
137 sbni_inb(struct sbni_softc *sc, enum sbni_reg reg)
138 {
139 return bus_space_read_1(
140 rman_get_bustag(sc->io_res),
141 rman_get_bushandle(sc->io_res),
142 sc->io_off + reg);
143 }
144
145 static __inline void
146 sbni_outb(struct sbni_softc *sc, enum sbni_reg reg, u_char value)
147 {
148 bus_space_write_1(
149 rman_get_bustag(sc->io_res),
150 rman_get_bushandle(sc->io_res),
151 sc->io_off + reg, value);
152 }
153
154 static __inline void
155 sbni_insb(struct sbni_softc *sc, u_char *to, u_int len)
156 {
157 bus_space_read_multi_1(
158 rman_get_bustag(sc->io_res),
159 rman_get_bushandle(sc->io_res),
160 sc->io_off + DAT, to, len);
161 }
162
163 static __inline void
164 sbni_outsb(struct sbni_softc *sc, u_char *from, u_int len)
165 {
166 bus_space_write_multi_1(
167 rman_get_bustag(sc->io_res),
168 rman_get_bushandle(sc->io_res),
169 sc->io_off + DAT, from, len);
170 }
171
172
173 /*
174 Valid combinations in CSR0 (for probing):
175
176 VALID_DECODER 0000,0011,1011,1010
177
178 ; 0 ; -
179 TR_REQ ; 1 ; +
180 TR_RDY ; 2 ; -
181 TR_RDY TR_REQ ; 3 ; +
182 BU_EMP ; 4 ; +
183 BU_EMP TR_REQ ; 5 ; +
184 BU_EMP TR_RDY ; 6 ; -
185 BU_EMP TR_RDY TR_REQ ; 7 ; +
186 RC_RDY ; 8 ; +
187 RC_RDY TR_REQ ; 9 ; +
188 RC_RDY TR_RDY ; 10 ; -
189 RC_RDY TR_RDY TR_REQ ; 11 ; -
190 RC_RDY BU_EMP ; 12 ; -
191 RC_RDY BU_EMP TR_REQ ; 13 ; -
192 RC_RDY BU_EMP TR_RDY ; 14 ; -
193 RC_RDY BU_EMP TR_RDY TR_REQ ; 15 ; -
194 */
195
196 #define VALID_DECODER (2 + 8 + 0x10 + 0x20 + 0x80 + 0x100 + 0x200)
197
198
199 int
200 sbni_probe(struct sbni_softc *sc)
201 {
202 u_char csr0;
203
204 csr0 = sbni_inb(sc, CSR0);
205 if (csr0 != 0xff && csr0 != 0x00) {
206 csr0 &= ~EN_INT;
207 if (csr0 & BU_EMP)
208 csr0 |= EN_INT;
209
210 if (VALID_DECODER & (1 << (csr0 >> 4)))
211 return (0);
212 }
213
214 return (ENXIO);
215 }
216
217
218 /*
219 * Install interface into kernel networking data structures
220 */
221 void
222 sbni_attach(struct sbni_softc *sc, int unit, struct sbni_flags flags)
223 {
224 struct ifnet *ifp;
225 u_char csr0;
226
227 ifp = &sc->arpcom.ac_if;
228 sbni_outb(sc, CSR0, 0);
229 set_initial_values(sc, flags);
230
231 callout_init(&sc->sbni_stat_timer);
232 /* Initialize ifnet structure */
233 ifp->if_softc = sc;
234 if_initname(ifp, "sbni", unit);
235 ifp->if_init = sbni_init;
236 ifp->if_start = sbni_start;
237 ifp->if_ioctl = sbni_ioctl;
238 ifp->if_watchdog = sbni_watchdog;
239 ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
240 ifq_set_ready(&ifp->if_snd);
241
242 /* report real baud rate */
243 csr0 = sbni_inb(sc, CSR0);
244 ifp->if_baudrate =
245 (csr0 & 0x01 ? 500000 : 2000000) / (1 << flags.rate);
246
247 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
248 ether_ifattach(ifp, sc->arpcom.ac_enaddr, NULL);
249
250 /* device attach does transition from UNCONFIGURED to IDLE state */
251
252 if_printf(ifp, "speed %ld, rxl ", ifp->if_baudrate);
253 if (sc->delta_rxl)
254 kprintf("auto\n");
255 else
256 kprintf("%d (fixed)\n", sc->cur_rxl_index);
257 }
258
259 /* -------------------------------------------------------------------------- */
260
261 static void
262 sbni_init(void *xsc)
263 {
264 struct sbni_softc *sc =xsc;
265 struct ifnet *ifp = &sc->arpcom.ac_if;
266
267 /*
268 * kludge to avoid multiple initialization when more than once
269 * protocols configured
270 */
271 if (ifp->if_flags & IFF_RUNNING)
272 return;
273 ifp->if_timer = 0;
274 card_start(sc);
275 callout_reset(&sc->sbni_stat_timer,hz / SBNI_HZ, sbni_timeout, sc);
276
277 ifp->if_flags |= IFF_RUNNING;
278 ifp->if_flags &= ~IFF_OACTIVE;
279
280 /* attempt to start output */
281 sbni_start(ifp);
282 }
283
284
285 static void
286 sbni_start(struct ifnet *ifp)
287 {
288 struct sbni_softc *sc = ifp->if_softc;
289 if (sc->tx_frameno == 0)
290 prepare_to_send(sc);
291 }
292
293
294 static void
295 sbni_stop(struct sbni_softc *sc)
296 {
297 sbni_outb(sc, CSR0, 0);
298 drop_xmit_queue(sc);
299
300 if (sc->rx_buf_p) {
301 m_freem(sc->rx_buf_p);
302 sc->rx_buf_p = NULL;
303 }
304
305 callout_stop(&sc->sbni_stat_timer);
306 }
307
308 /* -------------------------------------------------------------------------- */
309
310 /* interrupt handler */
311
312 /*
313 * SBNI12D-10, -11/ISA boards within "common interrupt" mode could not
314 * be looked as two independent single-channel devices. Every channel seems
315 * as Ethernet interface but interrupt handler must be common. Really, first
316 * channel ("master") driver only registers the handler. In it's struct softc
317 * it has got pointer to "slave" channel's struct softc and handles that's
318 * interrupts too.
319 * softc of successfully attached ISA SBNI boards is linked to list.
320 * While next board driver is initialized, it scans this list. If one
321 * has found softc with same irq and ioaddr different by 4 then it assumes
322 * this board to be "master".
323 */
324
325 void
326 sbni_intr(void *arg)
327 {
328 struct sbni_softc *sc;
329 int repeat;
330
331 sc = (struct sbni_softc *)arg;
332
333 do {
334 repeat = 0;
335 if (sbni_inb(sc, CSR0) & (RC_RDY | TR_RDY)) {
336 handle_channel(sc);
337 repeat = 1;
338 }
339 if (sc->slave_sc && /* second channel present */
340 (sbni_inb(sc->slave_sc, CSR0) & (RC_RDY | TR_RDY))) {
341 handle_channel(sc->slave_sc);
342 repeat = 1;
343 }
344 } while (repeat);
345 }
346
347
348 static void
349 handle_channel(struct sbni_softc *sc)
350 {
351 int req_ans;
352 u_char csr0;
353
354 sbni_outb(sc, CSR0, (sbni_inb(sc, CSR0) & ~EN_INT) | TR_REQ);
355
356 sc->timer_ticks = CHANGE_LEVEL_START_TICKS;
357 for (;;) {
358 csr0 = sbni_inb(sc, CSR0);
359 if ((csr0 & (RC_RDY | TR_RDY)) == 0)
360 break;
361
362 req_ans = !(sc->state & FL_PREV_OK);
363
364 if (csr0 & RC_RDY)
365 req_ans = recv_frame(sc);
366
367 /*
368 * TR_RDY always equals 1 here because we have owned the marker,
369 * and we set TR_REQ when disabled interrupts
370 */
371 csr0 = sbni_inb(sc, CSR0);
372 if ((csr0 & TR_RDY) == 0 || (csr0 & RC_RDY) != 0)
373 kprintf("sbni: internal error!\n");
374
375 /* if state & FL_NEED_RESEND != 0 then tx_frameno != 0 */
376 if (req_ans || sc->tx_frameno != 0)
377 send_frame(sc);
378 else {
379 /* send the marker without any data */
380 sbni_outb(sc, CSR0, sbni_inb(sc, CSR0) & ~TR_REQ);
381 }
382 }
383
384 sbni_outb(sc, CSR0, sbni_inb(sc, CSR0) | EN_INT);
385 }
386
387
388 /*
389 * Routine returns 1 if it need to acknoweledge received frame.
390 * Empty frame received without errors won't be acknoweledged.
391 */
392
393 static int
394 recv_frame(struct sbni_softc *sc)
395 {
396 u_int32_t crc;
397 u_int framelen, frameno, ack;
398 u_int is_first, frame_ok;
399
400 crc = CRC32_INITIAL;
401 framelen = 0;
402 if (check_fhdr(sc, &framelen, &frameno, &ack, &is_first, &crc)) {
403 frame_ok = framelen > 4 ?
404 upload_data(sc, framelen, frameno, is_first, crc) :
405 skip_tail(sc, framelen, crc);
406 if (frame_ok)
407 interpret_ack(sc, ack);
408 } else
409 frame_ok = 0;
410
411 sbni_outb(sc, CSR0, sbni_inb(sc, CSR0) ^ CT_ZER);
412 if (frame_ok) {
413 sc->state |= FL_PREV_OK;
414 if (framelen > 4)
415 sc->in_stats.all_rx_number++;
416 } else {
417 sc->state &= ~FL_PREV_OK;
418 change_level(sc);
419 sc->in_stats.all_rx_number++;
420 sc->in_stats.bad_rx_number++;
421 }
422
423 return (!frame_ok || framelen > 4);
424 }
425
426
427 static void
428 send_frame(struct sbni_softc *sc)
429 {
430 u_int32_t crc;
431 u_char csr0;
432
433 crc = CRC32_INITIAL;
434 if (sc->state & FL_NEED_RESEND) {
435
436 /* if frame was sended but not ACK'ed - resend it */
437 if (sc->trans_errors) {
438 sc->trans_errors--;
439 if (sc->framelen != 0)
440 sc->in_stats.resend_tx_number++;
441 } else {
442 /* cannot xmit with many attempts */
443 drop_xmit_queue(sc);
444 goto do_send;
445 }
446 } else
447 sc->trans_errors = TR_ERROR_COUNT;
448
449 send_frame_header(sc, &crc);
450 sc->state |= FL_NEED_RESEND;
451 /*
452 * FL_NEED_RESEND will be cleared after ACK, but if empty
453 * frame sended then in prepare_to_send next frame
454 */
455
456
457 if (sc->framelen) {
458 download_data(sc, &crc);
459 sc->in_stats.all_tx_number++;
460 sc->state |= FL_WAIT_ACK;
461 }
462
463 sbni_outsb(sc, (u_char *)&crc, sizeof crc);
464
465 do_send:
466 csr0 = sbni_inb(sc, CSR0);
467 sbni_outb(sc, CSR0, csr0 & ~TR_REQ);
468
469 if (sc->tx_frameno) {
470 /* next frame exists - request to send */
471 sbni_outb(sc, CSR0, csr0 | TR_REQ);
472 }
473 }
474
475
476 static void
477 download_data(struct sbni_softc *sc, u_int32_t *crc_p)
478 {
479 struct mbuf *m;
480 caddr_t data_p;
481 u_int data_len, pos, slice;
482
483 data_p = NULL; /* initialized to avoid warn */
484 pos = 0;
485
486 for (m = sc->tx_buf_p; m != NULL && pos < sc->pktlen; m = m->m_next) {
487 if (pos + m->m_len > sc->outpos) {
488 data_len = m->m_len - (sc->outpos - pos);
489 data_p = mtod(m, caddr_t) + (sc->outpos - pos);
490
491 goto do_copy;
492 } else
493 pos += m->m_len;
494 }
495
496 data_len = 0;
497
498 do_copy:
499 pos = 0;
500 do {
501 if (data_len) {
502 slice = min(data_len, sc->framelen - pos);
503 sbni_outsb(sc, data_p, slice);
504 *crc_p = calc_crc32(*crc_p, data_p, slice);
505
506 pos += slice;
507 if (data_len -= slice)
508 data_p += slice;
509 else {
510 do {
511 m = m->m_next;
512 } while (m != NULL && m->m_len == 0);
513
514 if (m) {
515 data_len = m->m_len;
516 data_p = mtod(m, caddr_t);
517 }
518 }
519 } else {
520 /* frame too short - zero padding */
521
522 pos = sc->framelen - pos;
523 while (pos--) {
524 sbni_outb(sc, DAT, 0);
525 *crc_p = CRC32(0, *crc_p);
526 }
527 return;
528 }
529 } while (pos < sc->framelen);
530 }
531
532
533 static int
534 upload_data(struct sbni_softc *sc, u_int framelen, u_int frameno,
535 u_int is_first, u_int32_t crc)
536 {
537 int frame_ok;
538
539 if (is_first) {
540 sc->wait_frameno = frameno;
541 sc->inppos = 0;
542 }
543
544 if (sc->wait_frameno == frameno) {
545
546 if (sc->inppos + framelen <= ETHER_MAX_LEN) {
547 frame_ok = append_frame_to_pkt(sc, framelen, crc);
548
549 /*
550 * if CRC is right but framelen incorrect then transmitter
551 * error was occured... drop entire packet
552 */
553 } else if ((frame_ok = skip_tail(sc, framelen, crc)) != 0) {
554 sc->wait_frameno = 0;
555 sc->inppos = 0;
556 sc->arpcom.ac_if.if_ierrors++;
557 /* now skip all frames until is_first != 0 */
558 }
559 } else
560 frame_ok = skip_tail(sc, framelen, crc);
561
562 if (is_first && !frame_ok) {
563 /*
564 * Frame has been violated, but we have stored
565 * is_first already... Drop entire packet.
566 */
567 sc->wait_frameno = 0;
568 sc->arpcom.ac_if.if_ierrors++;
569 }
570
571 return (frame_ok);
572 }
573
574
575 static __inline void send_complete(struct sbni_softc *);
576
577 static __inline void
578 send_complete(struct sbni_softc *sc)
579 {
580 m_freem(sc->tx_buf_p);
581 sc->tx_buf_p = NULL;
582 sc->arpcom.ac_if.if_opackets++;
583 }
584
585
586 static void
587 interpret_ack(struct sbni_softc *sc, u_int ack)
588 {
589 if (ack == FRAME_SENT_OK) {
590 sc->state &= ~FL_NEED_RESEND;
591
592 if (sc->state & FL_WAIT_ACK) {
593 sc->outpos += sc->framelen;
594
595 if (--sc->tx_frameno) {
596 sc->framelen = min(
597 sc->maxframe, sc->pktlen - sc->outpos);
598 } else {
599 send_complete(sc);
600 prepare_to_send(sc);
601 }
602 }
603 }
604
605 sc->state &= ~FL_WAIT_ACK;
606 }
607
608
609 /*
610 * Glue received frame with previous fragments of packet.
611 * Indicate packet when last frame would be accepted.
612 */
613
614 static int
615 append_frame_to_pkt(struct sbni_softc *sc, u_int framelen, u_int32_t crc)
616 {
617 caddr_t p;
618
619 if (sc->inppos + framelen > ETHER_MAX_LEN)
620 return (0);
621
622 if (!sc->rx_buf_p && !get_rx_buf(sc))
623 return (0);
624
625 p = sc->rx_buf_p->m_data + sc->inppos;
626 sbni_insb(sc, p, framelen);
627 if (calc_crc32(crc, p, framelen) != CRC32_REMAINDER)
628 return (0);
629
630 sc->inppos += framelen - 4;
631 if (--sc->wait_frameno == 0) { /* last frame received */
632 indicate_pkt(sc);
633 sc->arpcom.ac_if.if_ipackets++;
634 }
635
636 return (1);
637 }
638
639
640 /*
641 * Prepare to start output on adapter.
642 * Transmitter will be actually activated when marker has been accepted.
643 */
644
645 static void
646 prepare_to_send(struct sbni_softc *sc)
647 {
648 struct mbuf *m;
649 u_int len;
650
651 /* sc->tx_buf_p == NULL here! */
652 if (sc->tx_buf_p)
653 kprintf("sbni: memory leak!\n");
654
655 sc->outpos = 0;
656 sc->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
657
658 for (;;) {
659 sc->tx_buf_p = ifq_dequeue(&sc->arpcom.ac_if.if_snd, NULL);
660 if (sc->tx_buf_p == NULL) {
661 /* nothing to transmit... */
662 sc->pktlen = 0;
663 sc->tx_frameno = 0;
664 sc->framelen = 0;
665 sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
666 return;
667 }
668
669 for (len = 0, m = sc->tx_buf_p; m; m = m->m_next)
670 len += m->m_len;
671
672 if (len != 0)
673 break;
674 m_freem(sc->tx_buf_p);
675 }
676
677 if (len < SBNI_MIN_LEN)
678 len = SBNI_MIN_LEN;
679
680 sc->pktlen = len;
681 sc->tx_frameno = (len + sc->maxframe - 1) / sc->maxframe;
682 sc->framelen = min(len, sc->maxframe);
683
684 sbni_outb(sc, CSR0, sbni_inb(sc, CSR0) | TR_REQ);
685 sc->arpcom.ac_if.if_flags |= IFF_OACTIVE;
686 BPF_MTAP(&sc->arpcom.ac_if, sc->tx_buf_p);
687 }
688
689
690 static void
691 drop_xmit_queue(struct sbni_softc *sc)
692 {
693 if (sc->tx_buf_p) {
694 m_freem(sc->tx_buf_p);
695 sc->tx_buf_p = NULL;
696 sc->arpcom.ac_if.if_oerrors++;
697 }
698
699 ifq_purge(&sc->arpcom.ac_if.if_snd);
700
701 sc->tx_frameno = 0;
702 sc->framelen = 0;
703 sc->outpos = 0;
704 sc->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
705 sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
706 }
707
708
709 static void
710 send_frame_header(struct sbni_softc *sc, u_int32_t *crc_p)
711 {
712 u_int32_t crc;
713 u_int len_field;
714 u_char value;
715
716 crc = *crc_p;
717 len_field = sc->framelen + 6; /* CRC + frameno + reserved */
718
719 if (sc->state & FL_NEED_RESEND)
720 len_field |= FRAME_RETRY; /* non-first attempt... */
721
722 if (sc->outpos == 0)
723 len_field |= FRAME_FIRST;
724
725 len_field |= (sc->state & FL_PREV_OK) ? FRAME_SENT_OK : FRAME_SENT_BAD;
726 sbni_outb(sc, DAT, SBNI_SIG);
727
728 value = (u_char)len_field;
729 sbni_outb(sc, DAT, value);
730 crc = CRC32(value, crc);
731 value = (u_char)(len_field >> 8);
732 sbni_outb(sc, DAT, value);
733 crc = CRC32(value, crc);
734
735 sbni_outb(sc, DAT, sc->tx_frameno);
736 crc = CRC32(sc->tx_frameno, crc);
737 sbni_outb(sc, DAT, 0);
738 crc = CRC32(0, crc);
739 *crc_p = crc;
740 }
741
742
743 /*
744 * if frame tail not needed (incorrect number or received twice),
745 * it won't store, but CRC will be calculated
746 */
747
748 static int
749 skip_tail(struct sbni_softc *sc, u_int tail_len, u_int32_t crc)
750 {
751 while (tail_len--)
752 crc = CRC32(sbni_inb(sc, DAT), crc);
753
754 return (crc == CRC32_REMAINDER);
755 }
756
757
758 static int
759 check_fhdr(struct sbni_softc *sc, u_int *framelen, u_int *frameno,
760 u_int *ack, u_int *is_first, u_int32_t *crc_p)
761 {
762 u_int32_t crc;
763 u_char value;
764
765 crc = *crc_p;
766 if (sbni_inb(sc, DAT) != SBNI_SIG)
767 return (0);
768
769 value = sbni_inb(sc, DAT);
770 *framelen = (u_int)value;
771 crc = CRC32(value, crc);
772 value = sbni_inb(sc, DAT);
773 *framelen |= ((u_int)value) << 8;
774 crc = CRC32(value, crc);
775
776 *ack = *framelen & FRAME_ACK_MASK;
777 *is_first = (*framelen & FRAME_FIRST) != 0;
778
779 if ((*framelen &= FRAME_LEN_MASK) < 6 || *framelen > SBNI_MAX_FRAME - 3)
780 return (0);
781
782 value = sbni_inb(sc, DAT);
783 *frameno = (u_int)value;
784 crc = CRC32(value, crc);
785
786 crc = CRC32(sbni_inb(sc, DAT), crc); /* reserved byte */
787 *framelen -= 2;
788
789 *crc_p = crc;
790 return (1);
791 }
792
793
794 static int
795 get_rx_buf(struct sbni_softc *sc)
796 {
797 struct mbuf *m;
798
799 MGETHDR(m, MB_DONTWAIT, MT_DATA);
800 if (m == NULL) {
801 kprintf("%s: cannot allocate header mbuf\n",
802 sc->arpcom.ac_if.if_xname);
803 return (0);
804 }
805
806 /*
807 * We always put the received packet in a single buffer -
808 * either with just an mbuf header or in a cluster attached
809 * to the header. The +2 is to compensate for the alignment
810 * fixup below.
811 */
812 if (ETHER_MAX_LEN + 2 > MHLEN) {
813 /* Attach an mbuf cluster */
814 MCLGET(m, MB_DONTWAIT);
815 if ((m->m_flags & M_EXT) == 0) {
816 m_freem(m);
817 return (0);
818 }
819 }
820 m->m_pkthdr.len = m->m_len = ETHER_MAX_LEN + 2;
821
822 /*
823 * The +2 is to longword align the start of the real packet.
824 * (sizeof ether_header == 14)
825 * This is important for NFS.
826 */
827 m_adj(m, 2);
828 sc->rx_buf_p = m;
829 return (1);
830 }
831
832
833 static void
834 indicate_pkt(struct sbni_softc *sc)
835 {
836 struct ifnet *ifp = &sc->arpcom.ac_if;
837 struct mbuf *m;
838
839 m = sc->rx_buf_p;
840 m->m_pkthdr.rcvif = ifp;
841 m->m_pkthdr.len = m->m_len = sc->inppos;
842
843 ifp->if_input(ifp, m);
844 sc->rx_buf_p = NULL;
845 }
846
847 /* -------------------------------------------------------------------------- */
848
849 /*
850 * Routine checks periodically wire activity and regenerates marker if
851 * connect was inactive for a long time.
852 */
853
854 static void
855 sbni_timeout(void *xsc)
856 {
857 struct sbni_softc *sc = xsc;
858 u_char csr0;
859
860 lwkt_serialize_enter(sc->arpcom.ac_if.if_serializer);
861
862 csr0 = sbni_inb(sc, CSR0);
863 if (csr0 & RC_CHK) {
864
865 if (sc->timer_ticks) {
866 if (csr0 & (RC_RDY | BU_EMP))
867 /* receiving not active */
868 sc->timer_ticks--;
869 } else {
870 sc->in_stats.timeout_number++;
871 if (sc->delta_rxl)
872 timeout_change_level(sc);
873
874 sbni_outb(sc, CSR1, *(u_char *)&sc->csr1 | PR_RES);
875 csr0 = sbni_inb(sc, CSR0);
876 }
877 }
878
879 sbni_outb(sc, CSR0, csr0 | RC_CHK);
880 callout_reset(&sc->sbni_stat_timer, hz / SBNI_HZ, sbni_timeout, sc);
881
882 lwkt_serialize_exit(sc->arpcom.ac_if.if_serializer);
883 }
884
885 /* -------------------------------------------------------------------------- */
886
887 static void
888 card_start(struct sbni_softc *sc)
889 {
890 sc->timer_ticks = CHANGE_LEVEL_START_TICKS;
891 sc->state &= ~(FL_WAIT_ACK | FL_NEED_RESEND);
892 sc->state |= FL_PREV_OK;
893
894 sc->inppos = 0;
895 sc->wait_frameno = 0;
896
897 sbni_outb(sc, CSR1, *(u_char *)&sc->csr1 | PR_RES);
898 sbni_outb(sc, CSR0, EN_INT);
899 }
900
901 /* -------------------------------------------------------------------------- */
902
903 /*
904 * Device timeout/watchdog routine. Entered if the device neglects to
905 * generate an interrupt after a transmit has been started on it.
906 */
907
908 static void
909 sbni_watchdog(struct ifnet *ifp)
910 {
911 log(LOG_ERR, "%s: device timeout\n", ifp->if_xname);
912 ifp->if_oerrors++;
913 }
914
915
916 static u_char rxl_tab[] = {
917 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
918 0x0a, 0x0c, 0x0f, 0x16, 0x18, 0x1a, 0x1c, 0x1f
919 };
920
921 #define SIZE_OF_TIMEOUT_RXL_TAB 4
922 static u_char timeout_rxl_tab[] = {
923 0x03, 0x05, 0x08, 0x0b
924 };
925
926 static void
927 set_initial_values(struct sbni_softc *sc, struct sbni_flags flags)
928 {
929 if (flags.fixed_rxl) {
930 sc->delta_rxl = 0; /* disable receive level autodetection */
931 sc->cur_rxl_index = flags.rxl;
932 } else {
933 sc->delta_rxl = DEF_RXL_DELTA;
934 sc->cur_rxl_index = DEF_RXL;
935 }
936
937 sc->csr1.rate = flags.fixed_rate ? flags.rate : DEFAULT_RATE;
938 sc->csr1.rxl = rxl_tab[sc->cur_rxl_index];
939 sc->maxframe = DEFAULT_FRAME_LEN;
940
941 /*
942 * generate Ethernet address (0x00ff01xxxxxx)
943 */
944 *(u_int16_t *) sc->arpcom.ac_enaddr = htons(0x00ff);
945 if (flags.mac_addr) {
946 *(u_int32_t *) (sc->arpcom.ac_enaddr + 2) =
947 htonl(flags.mac_addr | 0x01000000);
948 } else {
949 *(u_char *) (sc->arpcom.ac_enaddr + 2) = 0x01;
950 read_random_unlimited(sc->arpcom.ac_enaddr + 3, 3);
951 }
952 }
953
954
955 #ifdef SBNI_DUAL_COMPOUND
956
957 struct sbni_softc *
958 connect_to_master(struct sbni_softc *sc)
959 {
960 struct sbni_softc *p, *p_prev;
961
962 for (p = sbni_headlist, p_prev = NULL; p; p_prev = p, p = p->link) {
963 if (rman_get_start(p->io_res) == rman_get_start(sc->io_res) + 4 ||
964 rman_get_start(p->io_res) == rman_get_start(sc->io_res) - 4) {
965 p->slave_sc = sc;
966 if (p_prev)
967 p_prev->link = p->link;
968 else
969 sbni_headlist = p->link;
970 return p;
971 }
972 }
973
974 return (NULL);
975 }
976
977 #endif /* SBNI_DUAL_COMPOUND */
978
979
980 /* Receive level auto-selection */
981
982 static void
983 change_level(struct sbni_softc *sc)
984 {
985 if (sc->delta_rxl == 0) /* do not auto-negotiate RxL */
986 return;
987
988 if (sc->cur_rxl_index == 0)
989 sc->delta_rxl = 1;
990 else if (sc->cur_rxl_index == 15)
991 sc->delta_rxl = -1;
992 else if (sc->cur_rxl_rcvd < sc->prev_rxl_rcvd)
993 sc->delta_rxl = -sc->delta_rxl;
994
995 sc->csr1.rxl = rxl_tab[sc->cur_rxl_index += sc->delta_rxl];
996 sbni_inb(sc, CSR0); /* it needed for PCI cards */
997 sbni_outb(sc, CSR1, *(u_char *)&sc->csr1);
998
999 sc->prev_rxl_rcvd = sc->cur_rxl_rcvd;
1000 sc->cur_rxl_rcvd = 0;
1001 }
1002
1003
1004 static void
1005 timeout_change_level(struct sbni_softc *sc)
1006 {
1007 sc->cur_rxl_index = timeout_rxl_tab[sc->timeout_rxl];
1008 if (++sc->timeout_rxl >= 4)
1009 sc->timeout_rxl = 0;
1010
1011 sc->csr1.rxl = rxl_tab[sc->cur_rxl_index];
1012 sbni_inb(sc, CSR0);
1013 sbni_outb(sc, CSR1, *(u_char *)&sc->csr1);
1014
1015 sc->prev_rxl_rcvd = sc->cur_rxl_rcvd;
1016 sc->cur_rxl_rcvd = 0;
1017 }
1018
1019 /* -------------------------------------------------------------------------- */
1020
1021 /*
1022 * Process an ioctl request. This code needs some work - it looks
1023 * pretty ugly.
1024 */
1025
1026 static int
1027 sbni_ioctl(struct ifnet *ifp, u_long command, caddr_t data, struct ucred *cr)
1028 {
1029 struct sbni_softc *sc;
1030 struct ifreq *ifr;
1031 struct sbni_in_stats *in_stats;
1032 struct sbni_flags flags;
1033 int error;
1034
1035 sc = ifp->if_softc;
1036 ifr = (struct ifreq *)data;
1037 error = 0;
1038
1039 switch (command) {
1040 case SIOCSIFFLAGS:
1041 /*
1042 * If the interface is marked up and stopped, then start it.
1043 * If it is marked down and running, then stop it.
1044 */
1045 if (ifp->if_flags & IFF_UP) {
1046 if (!(ifp->if_flags & IFF_RUNNING))
1047 sbni_init(sc);
1048 } else {
1049 if (ifp->if_flags & IFF_RUNNING) {
1050 sbni_stop(sc);
1051 ifp->if_flags &= ~IFF_RUNNING;
1052 }
1053 }
1054 break;
1055
1056 case SIOCADDMULTI:
1057 case SIOCDELMULTI:
1058 /*
1059 * Multicast list has changed; set the hardware filter
1060 * accordingly.
1061 */
1062 error = 0;
1063 /* if (ifr == NULL)
1064 error = EAFNOSUPPORT; */
1065 break;
1066
1067 case SIOCSIFMTU:
1068 if (ifr->ifr_mtu > ETHERMTU)
1069 error = EINVAL;
1070 else
1071 ifp->if_mtu = ifr->ifr_mtu;
1072 break;
1073
1074 /*
1075 * SBNI specific ioctl
1076 */
1077 case SIOCGHWFLAGS: /* get flags */
1078 bcopy((caddr_t) sc->arpcom.ac_enaddr+3, (caddr_t) &flags, 3);
1079 flags.rxl = sc->cur_rxl_index;
1080 flags.rate = sc->csr1.rate;
1081 flags.fixed_rxl = (sc->delta_rxl == 0);
1082 flags.fixed_rate = 1;
1083 ifr->ifr_data = *(caddr_t*) &flags;
1084 break;
1085
1086 case SIOCGINSTATS:
1087 in_stats = (struct sbni_in_stats *)ifr->ifr_data;
1088 bcopy((void *)(&(sc->in_stats)), (void *)in_stats,
1089 sizeof(struct sbni_in_stats));
1090 break;
1091
1092 case SIOCSHWFLAGS: /* set flags */
1093 /* root only */
1094 error = suser_cred(cr, NULL_CRED_OKAY);
1095 /* NOTE: returns EPERM if no proc */
1096 if (error)
1097 break;
1098 flags = *(struct sbni_flags*)&ifr->ifr_data;
1099 if (flags.fixed_rxl) {
1100 sc->delta_rxl = 0;
1101 sc->cur_rxl_index = flags.rxl;
1102 } else {
1103 sc->delta_rxl = DEF_RXL_DELTA;
1104 sc->cur_rxl_index = DEF_RXL;
1105 }
1106 sc->csr1.rxl = rxl_tab[sc->cur_rxl_index];
1107 sc->csr1.rate = flags.fixed_rate ? flags.rate : DEFAULT_RATE;
1108 if (flags.mac_addr)
1109 bcopy((caddr_t) &flags,
1110 (caddr_t) sc->arpcom.ac_enaddr+3, 3);
1111
1112 /* Don't be afraid... */
1113 sbni_outb(sc, CSR1, *(char*)(&sc->csr1) | PR_RES);
1114 break;
1115
1116 case SIOCRINSTATS:
1117 if (!(error = suser_cred(cr, NULL_CRED_OKAY))) /* root only */
1118 bzero(&sc->in_stats, sizeof(struct sbni_in_stats));
1119 break;
1120
1121 default:
1122 error = ether_ioctl(ifp, command, data);
1123 break;
1124 }
1125 return (error);
1126 }
1127
1128 /* -------------------------------------------------------------------------- */
1129
1130 #ifdef ASM_CRC
1131
1132 static u_int32_t
1133 calc_crc32(u_int32_t crc, caddr_t p, u_int len)
1134 {
1135 u_int32_t _crc;
1136 _crc = crc;
1137
1138 __asm __volatile (
1139 "xorl %%ebx, %%ebx\n"
1140 "movl %1, %%esi\n"
1141 "movl %2, %%ecx\n"
1142 "movl $crc32tab, %%edi\n"
1143 "shrl $2, %%ecx\n"
1144 "jz 1f\n"
1145
1146 ".align 4\n"
1147 "0:\n"
1148 "movb %%al, %%bl\n"
1149 "movl (%%esi), %%edx\n"
1150 "shrl $8, %%eax\n"
1151 "xorb %%dl, %%bl\n"
1152 "shrl $8, %%edx\n"
1153 "xorl (%%edi,%%ebx,4), %%eax\n"
1154
1155 "movb %%al, %%bl\n"
1156 "shrl $8, %%eax\n"
1157 "xorb %%dl, %%bl\n"
1158 "shrl $8, %%edx\n"
1159 "xorl (%%edi,%%ebx,4), %%eax\n"
1160
1161 "movb %%al, %%bl\n"
1162 "shrl $8, %%eax\n"
1163 "xorb %%dl, %%bl\n"
1164 "movb %%dh, %%dl\n"
1165 "xorl (%%edi,%%ebx,4), %%eax\n"
1166
1167 "movb %%al, %%bl\n"
1168 "shrl $8, %%eax\n"
1169 "xorb %%dl, %%bl\n"
1170 "addl $4, %%esi\n"
1171 "xorl (%%edi,%%ebx,4), %%eax\n"
1172
1173 "decl %%ecx\n"
1174 "jnz 0b\n"
1175
1176 "1:\n"
1177 "movl %2, %%ecx\n"
1178 "andl $3, %%ecx\n"
1179 "jz 2f\n"
1180
1181 "movb %%al, %%bl\n"
1182 "shrl $8, %%eax\n"
1183 "xorb (%%esi), %%bl\n"
1184 "xorl (%%edi,%%ebx,4), %%eax\n"
1185
1186 "decl %%ecx\n"
1187 "jz 2f\n"
1188
1189 "movb %%al, %%bl\n"
1190 "shrl $8, %%eax\n"
1191 "xorb 1(%%esi), %%bl\n"
1192 "xorl (%%edi,%%ebx,4), %%eax\n"
1193
1194 "decl %%ecx\n"
1195 "jz 2f\n"
1196
1197 "movb %%al, %%bl\n"
1198 "shrl $8, %%eax\n"
1199 "xorb 2(%%esi), %%bl\n"
1200 "xorl (%%edi,%%ebx,4), %%eax\n"
1201 "2:\n"
1202 :
1203 : "a" (_crc), "g" (p), "g" (len)
1204 : "bx", "cx", "dx", "si", "di"
1205 );
1206
1207 return (_crc);
1208 }
1209
1210 #else /* ASM_CRC */
1211
1212 static u_int32_t
1213 calc_crc32(u_int32_t crc, caddr_t p, u_int len)
1214 {
1215 while (len--)
1216 crc = CRC32(*p++, crc);
1217
1218 return (crc);
1219 }
1220
1221 #endif /* ASM_CRC */
1222
1223
1224 static u_int32_t crc32tab[] __attribute__ ((aligned(8))) = {
1225 0xD202EF8D, 0xA505DF1B, 0x3C0C8EA1, 0x4B0BBE37,
1226 0xD56F2B94, 0xA2681B02, 0x3B614AB8, 0x4C667A2E,
1227 0xDCD967BF, 0xABDE5729, 0x32D70693, 0x45D03605,
1228 0xDBB4A3A6, 0xACB39330, 0x35BAC28A, 0x42BDF21C,
1229 0xCFB5FFE9, 0xB8B2CF7F, 0x21BB9EC5, 0x56BCAE53,
1230 0xC8D83BF0, 0xBFDF0B66, 0x26D65ADC, 0x51D16A4A,
1231 0xC16E77DB, 0xB669474D, 0x2F6016F7, 0x58672661,
1232 0xC603B3C2, 0xB1048354, 0x280DD2EE, 0x5F0AE278,
1233 0xE96CCF45, 0x9E6BFFD3, 0x0762AE69, 0x70659EFF,
1234 0xEE010B5C, 0x99063BCA, 0x000F6A70, 0x77085AE6,
1235 0xE7B74777, 0x90B077E1, 0x09B9265B, 0x7EBE16CD,
1236 0xE0DA836E, 0x97DDB3F8, 0x0ED4E242, 0x79D3D2D4,
1237 0xF4DBDF21, 0x83DCEFB7, 0x1AD5BE0D, 0x6DD28E9B,
1238 0xF3B61B38, 0x84B12BAE, 0x1DB87A14, 0x6ABF4A82,
1239 0xFA005713, 0x8D076785, 0x140E363F, 0x630906A9,
1240 0xFD6D930A, 0x8A6AA39C, 0x1363F226, 0x6464C2B0,
1241 0xA4DEAE1D, 0xD3D99E8B, 0x4AD0CF31, 0x3DD7FFA7,
1242 0xA3B36A04, 0xD4B45A92, 0x4DBD0B28, 0x3ABA3BBE,
1243 0xAA05262F, 0xDD0216B9, 0x440B4703, 0x330C7795,
1244 0xAD68E236, 0xDA6FD2A0, 0x4366831A, 0x3461B38C,
1245 0xB969BE79, 0xCE6E8EEF, 0x5767DF55, 0x2060EFC3,
1246 0xBE047A60, 0xC9034AF6, 0x500A1B4C, 0x270D2BDA,
1247 0xB7B2364B, 0xC0B506DD, 0x59BC5767, 0x2EBB67F1,
1248 0xB0DFF252, 0xC7D8C2C4, 0x5ED1937E, 0x29D6A3E8,
1249 0x9FB08ED5, 0xE8B7BE43, 0x71BEEFF9, 0x06B9DF6F,
1250 0x98DD4ACC, 0xEFDA7A5A, 0x76D32BE0, 0x01D41B76,
1251 0x916B06E7, 0xE66C3671, 0x7F6567CB, 0x0862575D,
1252 0x9606C2FE, 0xE101F268, 0x7808A3D2, 0x0F0F9344,
1253 0x82079EB1, 0xF500AE27, 0x6C09FF9D, 0x1B0ECF0B,
1254 0x856A5AA8, 0xF26D6A3E, 0x6B643B84, 0x1C630B12,
1255 0x8CDC1683, 0xFBDB2615, 0x62D277AF, 0x15D54739,
1256 0x8BB1D29A, 0xFCB6E20C, 0x65BFB3B6, 0x12B88320,
1257 0x3FBA6CAD, 0x48BD5C3B, 0xD1B40D81, 0xA6B33D17,
1258 0x38D7A8B4, 0x4FD09822, 0xD6D9C998, 0xA1DEF90E,
1259 0x3161E49F, 0x4666D409, 0xDF6F85B3, 0xA868B525,
1260 0x360C2086, 0x410B1010, 0xD80241AA, 0xAF05713C,
1261 0x220D7CC9, 0x550A4C5F, 0xCC031DE5, 0xBB042D73,
1262 0x2560B8D0, 0x52678846, 0xCB6ED9FC, 0xBC69E96A,
1263 0x2CD6F4FB, 0x5BD1C46D, 0xC2D895D7, 0xB5DFA541,
1264 0x2BBB30E2, 0x5CBC0074, 0xC5B551CE, 0xB2B26158,
1265 0x04D44C65, 0x73D37CF3, 0xEADA2D49, 0x9DDD1DDF,
1266 0x03B9887C, 0x74BEB8EA, 0xEDB7E950, 0x9AB0D9C6,
1267 0x0A0FC457, 0x7D08F4C1, 0xE401A57B, 0x930695ED,
1268 0x0D62004E, 0x7A6530D8, 0xE36C6162, 0x946B51F4,
1269 0x19635C01, 0x6E646C97, 0xF76D3D2D, 0x806A0DBB,
1270 0x1E0E9818, 0x6909A88E, 0xF000F934, 0x8707C9A2,
1271 0x17B8D433, 0x60BFE4A5, 0xF9B6B51F, 0x8EB18589,
1272 0x10D5102A, 0x67D220BC, 0xFEDB7106, 0x89DC4190,
1273 0x49662D3D, 0x3E611DAB, 0xA7684C11, 0xD06F7C87,
1274 0x4E0BE924, 0x390CD9B2, 0xA0058808, 0xD702B89E,
1275 0x47BDA50F, 0x30BA9599, 0xA9B3C423, 0xDEB4F4B5,
1276 0x40D06116, 0x37D75180, 0xAEDE003A, 0xD9D930AC,
1277 0x54D13D59, 0x23D60DCF, 0xBADF5C75, 0xCDD86CE3,
1278 0x53BCF940, 0x24BBC9D6, 0xBDB2986C, 0xCAB5A8FA,
1279 0x5A0AB56B, 0x2D0D85FD, 0xB404D447, 0xC303E4D1,
1280 0x5D677172, 0x2A6041E4, 0xB369105E, 0xC46E20C8,
1281 0x72080DF5, 0x050F3D63, 0x9C066CD9, 0xEB015C4F,
1282 0x7565C9EC, 0x0262F97A, 0x9B6BA8C0, 0xEC6C9856,
1283 0x7CD385C7, 0x0BD4B551, 0x92DDE4EB, 0xE5DAD47D,
1284 0x7BBE41DE, 0x0CB97148, 0x95B020F2, 0xE2B71064,
1285 0x6FBF1D91, 0x18B82D07, 0x81B17CBD, 0xF6B64C2B,
1286 0x68D2D988, 0x1FD5E91E, 0x86DCB8A4, 0xF1DB8832,
1287 0x616495A3, 0x1663A535, 0x8F6AF48F, 0xF86DC419,
1288 0x660951BA, 0x110E612C, 0x88073096, 0xFF000000
1289 };
Port diff from OpenBSD to DragonFly