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