21f4f5c56a86167e009681b99c132a036c72ecab
[dragonfly.git] / sys / dev / netif / sbni / if_sbni.c
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 };