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