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