workbench/devs/networks/rhine/unit.c

   1 /*
   2
   3 Copyright (C) 2001-2017 Neil Cafferkey
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful, but
  11 WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13 General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18 MA 02111-1307, USA.
  19
  20 */
  21
  22
  23 #include <exec/memory.h>
  24 #include <exec/execbase.h>
  25 #include <exec/errors.h>
  26 #include <exec/tasks.h>
  27
  28 #include <proto/exec.h>
  29 #include <proto/alib.h>
  30 #include <proto/utility.h>
  31 #include <proto/timer.h>
  32
  33 #include "device.h"
  34 #include "task.h"
  35 #include "rhine.h"
  36
  37 #include "unit_protos.h"
  38 #include "request_protos.h"
  39 #include "timer_protos.h"
  40
  41
  42 #define TASK_PRIORITY 0
  43 #define STACK_SIZE 4096
  44 #define INT_MASK 0xffff
  45 #define TX_DESC_SIZE (RH_DESCSIZE * 2 + ETH_HEADERSIZE + 2)
  46
  47 VOID DeinitialiseAdapter(struct DevUnit *unit, struct DevBase *base);
  48 static struct AddressRange *FindMulticastRange(struct DevUnit *unit,
  49    ULONG lower_bound_left, UWORD lower_bound_right, ULONG upper_bound_left,
  50    UWORD upper_bound_right, struct DevBase *base);
  51 static VOID SetMulticast(struct DevUnit *unit, struct DevBase *base);
  52 static BOOL StatusInt(REG(a1, struct DevUnit *unit), REG(a5, APTR int_code));
  53 static VOID RXInt(REG(a1, struct DevUnit *unit), REG(a6, APTR int_code));
  54 static VOID DistributeRXPacket(struct DevUnit *unit, const UBYTE *packet,
  55    UWORD packet_size, struct DevBase *base);
  56 static VOID CopyPacket(struct DevUnit *unit, struct IOSana2Req *request,
  57    UWORD packet_size, UWORD packet_type, const UBYTE *buffer,
  58    struct DevBase *base);
  59 static BOOL AddressFilter(struct DevUnit *unit, UBYTE *address,
  60    struct DevBase *base);
  61 static VOID TXInt(REG(a1, struct DevUnit *unit), REG(a6, APTR int_code));
  62 static VOID TXEndInt(REG(a1, struct DevUnit *unit), REG(a5, APTR int_code));
  63 static VOID RetireTXSlot(struct DevUnit *unit, UWORD slot,
  64    struct DevBase *base);
  65 static VOID ResetHandler(REG(a1, struct DevUnit *unit),
  66    REG(a6, APTR int_code));
  67 static VOID ReportEvents(struct DevUnit *unit, ULONG events,
  68    struct DevBase *base);
  69 static VOID UnitTask(struct DevUnit *unit);
  70 UWORD ReadMII(struct DevUnit *unit, UWORD phy_no, UWORD reg_no,
  71    struct DevBase *base);
  72
  73
  74
  75 /****i* rhine.device/CreateUnit ********************************************
  76 *
  77 *   NAME
  78 *       CreateUnit -- Create a unit.
  79 *
  80 *   SYNOPSIS
  81 *       unit = CreateUnit(index, io_base, id, card,
  82 *           io_tags, bus)
  83 *
  84 *       struct DevUnit *CreateUnit(ULONG, APTR, UWORD, APTR,
  85 *           struct TagItem *, UWORD);
  86 *
  87 *   FUNCTION
  88 *       Creates a new unit.
  89 *
  90 ****************************************************************************
  91 *
  92 */
  93
  94 struct DevUnit *CreateUnit(ULONG index, APTR card,
  95    const struct TagItem *io_tags, UWORD bus, struct DevBase *base)
  96 {
  97    BOOL success = TRUE;
  98    struct DevUnit *unit;
  99    struct Task *task;
 100    struct MsgPort *port;
 101    UWORD i;
 102    ULONG *desc, desc_p, buffer_p, dma_size;
 103    APTR stack;
 104
 105    unit = AllocMem(sizeof(struct DevUnit), MEMF_CLEAR | MEMF_PUBLIC);
 106    if(unit == NULL)
 107       success = FALSE;
 108
 109    if(success)
 110    {
 111       /* Initialise lists etc. */
 112
 113       NewList((APTR)&unit->openers);
 114       NewList((APTR)&unit->type_trackers);
 115       NewList((APTR)&unit->multicast_ranges);
 116
 117       unit->index = index;
 118       unit->device = base;
 119       unit->card = card;
 120       unit->bus = bus;
 121
 122       /* Store I/O hooks */
 123
 124       unit->ByteIn =
 125          (APTR)GetTagData(IOTAG_ByteIn, (UPINT)NULL, io_tags);
 126       unit->ByteOut =
 127          (APTR)GetTagData(IOTAG_ByteOut, (UPINT)NULL, io_tags);
 128       unit->LEWordIn =
 129          (APTR)GetTagData(IOTAG_LEWordIn, (UPINT)NULL, io_tags);
 130       unit->LELongIn =
 131          (APTR)GetTagData(IOTAG_LELongIn, (UPINT)NULL, io_tags);
 132       unit->LEWordOut =
 133          (APTR)GetTagData(IOTAG_LEWordOut, (UPINT)NULL, io_tags);
 134       unit->LELongOut =
 135          (APTR)GetTagData(IOTAG_LELongOut, (UPINT)NULL, io_tags);
 136       unit->AllocDMAMem =
 137          (APTR)GetTagData(IOTAG_AllocDMAMem, (UPINT)NULL, io_tags);
 138       unit->FreeDMAMem =
 139          (APTR)GetTagData(IOTAG_FreeDMAMem, (UPINT)NULL, io_tags);
 140       if(unit->ByteIn == NULL
 141          || unit->ByteOut == NULL
 142          || unit->LEWordIn == NULL
 143          || unit->LELongIn == NULL
 144          || unit->LEWordOut == NULL
 145          || unit->LELongOut == NULL
 146          || unit->AllocDMAMem == NULL
 147          || unit->FreeDMAMem == NULL)
 148          success = FALSE;
 149    }
 150
 151    if(success)
 152    {
 153       InitSemaphore(&unit->access_lock);
 154
 155       /* Create the message ports for queuing requests */
 156
 157       for(i = 0; i < REQUEST_QUEUE_COUNT; i++)
 158       {
 159          unit->request_ports[i] = port = AllocMem(sizeof(struct MsgPort),
 160             MEMF_PUBLIC | MEMF_CLEAR);
 161          if(port == NULL)
 162             success = FALSE;
 163
 164          if(success)
 165          {
 166             NewList(&port->mp_MsgList);
 167             port->mp_Flags = PA_IGNORE;
 168          }
 169       }
 170       if(success)
 171          unit->request_ports[WRITE_QUEUE]->mp_SigTask = &unit->tx_int;
 172    }
 173
 174    if(success)
 175    {
 176       /* Allocate TX descriptors */
 177
 178       desc = unit->AllocDMAMem(unit->card, TX_DESC_SIZE * TX_SLOT_COUNT, 16);
 179       if(desc == NULL)
 180          success = FALSE;
 181    }
 182
 183    if(success)
 184    {
 185       /* Fill arrays of virtual and physical addresses of TX descriptors */
 186
 187       dma_size = TX_DESC_SIZE * TX_SLOT_COUNT;
 188       desc_p = (ULONG)(UPINT)CachePreDMA(desc, &dma_size, 0);
 189       if(dma_size != TX_DESC_SIZE * TX_SLOT_COUNT)
 190          success = FALSE;
 191       CachePostDMA(desc, &dma_size, 0);
 192
 193       for(i = 0; i < TX_SLOT_COUNT; i++)
 194       {
 195          unit->tx_descs[i] = desc;
 196          desc += TX_DESC_SIZE / sizeof(ULONG);
 197          unit->tx_descs_p[i] = desc_p;
 198          desc_p += TX_DESC_SIZE;
 199       }
 200    }
 201
 202    if(success)
 203    {
 204       /* Allocate RX descriptors */
 205
 206       desc = unit->AllocDMAMem(unit->card, RH_DESCSIZE * RX_SLOT_COUNT, 16);
 207       if(desc == NULL)
 208          success = FALSE;
 209    }
 210
 211    if(success)
 212    {
 213       /* Fill arrays of virtual and physical addresses of TX descriptors */
 214
 215       dma_size = RH_DESCSIZE * RX_SLOT_COUNT;
 216       desc_p = (ULONG)(UPINT)CachePreDMA(desc, &dma_size, 0);
 217       if(dma_size != RH_DESCSIZE * RX_SLOT_COUNT)
 218          success = FALSE;
 219       CachePostDMA(desc, &dma_size, 0);
 220
 221       for(i = 0; i < RX_SLOT_COUNT; i++)
 222       {
 223          unit->rx_descs[i] = desc;
 224          desc += RH_DESCSIZE / sizeof(ULONG);
 225          unit->rx_descs_p[i] = desc_p;
 226          desc_p += RH_DESCSIZE;
 227       }
 228
 229       /* Allocate packet buffers */
 230
 231       unit->tx_buffer = unit->AllocDMAMem(unit->card, FRAME_BUFFER_SIZE, 4);
 232       if(unit->tx_buffer == NULL)
 233          success = FALSE;
 234
 235       for(i = 0; i < RX_SLOT_COUNT; i++)
 236       {
 237          unit->rx_buffers[i] = unit->AllocDMAMem(unit->card,
 238             FRAME_BUFFER_SIZE, 4);
 239          if(unit->rx_buffers[i] == NULL)
 240             success = FALSE;
 241       }
 242
 243       unit->tx_requests = AllocVec(sizeof(APTR) * TX_SLOT_COUNT,
 244          MEMF_PUBLIC);
 245       if(unit->tx_requests == NULL)
 246          success = FALSE;
 247    }
 248
 249    if(success)
 250    {
 251       /* Construct RX ring */
 252
 253       for(i = 0; i < RX_SLOT_COUNT; i++)
 254       {
 255          desc = unit->rx_descs[i];
 256          desc[RH_DESC_RXSTATUS] = MakeLELong(RH_DESC_RXSTATUSF_INUSE);
 257          desc[RH_DESC_RXCONTROL] = MakeLELong(FRAME_BUFFER_SIZE);
 258          dma_size = FRAME_BUFFER_SIZE;
 259          buffer_p =
 260             (ULONG)(UPINT)CachePreDMA(unit->rx_buffers[i], &dma_size, 0);
 261          if(dma_size != FRAME_BUFFER_SIZE)
 262             success = FALSE;
 263          desc[RH_DESC_DATA] = MakeLELong(buffer_p);
 264          desc[RH_DESC_NEXT] =
 265             MakeLELong(unit->rx_descs_p[(i + 1) % RX_SLOT_COUNT]);
 266          desc += RH_DESCSIZE / sizeof(ULONG);
 267       }
 268       dma_size = RH_DESCSIZE * RX_SLOT_COUNT;
 269       CachePreDMA(unit->rx_descs, &dma_size, 0);
 270    }
 271
 272    if(success)
 273    {
 274       /* Initialise network adapter hardware */
 275
 276       success = InitialiseAdapter(unit, FALSE, base);
 277       unit->flags |= UNITF_HAVEADAPTER;
 278    }
 279
 280    if(success)
 281    {
 282       /* Record maximum speed in BPS */
 283
 284       unit->speed = 100000000;
 285
 286       /* Initialise interrupts */
 287
 288       unit->status_int.is_Code = (APTR)StatusInt;
 289       unit->status_int.is_Data = unit;
 290
 291       unit->rx_int.is_Node.ln_Name =
 292          base->device.dd_Library.lib_Node.ln_Name;
 293       unit->rx_int.is_Code = (APTR)RXInt;
 294       unit->rx_int.is_Data = unit;
 295
 296       unit->tx_int.is_Node.ln_Name =
 297          base->device.dd_Library.lib_Node.ln_Name;
 298       unit->tx_int.is_Code = (APTR)TXInt;
 299       unit->tx_int.is_Data = unit;
 300
 301       unit->tx_end_int.is_Node.ln_Name =
 302          base->device.dd_Library.lib_Node.ln_Name;
 303       unit->tx_end_int.is_Code = (APTR)TXEndInt;
 304       unit->tx_end_int.is_Data = unit;
 305
 306       unit->reset_handler.is_Node.ln_Name =
 307          base->device.dd_Library.lib_Node.ln_Name;
 308       unit->reset_handler.is_Code = (APTR)ResetHandler;
 309       unit->reset_handler.is_Data = unit;
 310
 311       unit->request_ports[WRITE_QUEUE]->mp_Flags = PA_SOFTINT;
 312
 313       /* Create a new task */
 314
 315       unit->task = task =
 316          AllocMem(sizeof(struct Task), MEMF_PUBLIC | MEMF_CLEAR);
 317       if(task == NULL)
 318          success = FALSE;
 319    }
 320
 321    if(success)
 322    {
 323       stack = AllocMem(STACK_SIZE, MEMF_PUBLIC);
 324       if(stack == NULL)
 325          success = FALSE;
 326    }
 327
 328    if(success)
 329    {
 330       /* Initialise and start task */
 331
 332       task->tc_Node.ln_Type = NT_TASK;
 333       task->tc_Node.ln_Pri = TASK_PRIORITY;
 334       task->tc_Node.ln_Name = base->device.dd_Library.lib_Node.ln_Name;
 335       task->tc_SPUpper = stack + STACK_SIZE;
 336       task->tc_SPLower = stack;
 337       task->tc_SPReg = task->tc_SPUpper;
 338       NewList(&task->tc_MemEntry);
 339
 340       if(AddUnitTask(task, UnitTask, unit) != NULL)
 341          unit->flags |= UNITF_TASKADDED;
 342       else
 343          success = FALSE;
 344    }
 345
 346    if(!success)
 347    {
 348       DeleteUnit(unit, base);
 349       unit = NULL;
 350    }
 351
 352    return unit;
 353 }
 354
 355
 356
 357 /****i* rhine.device/DeleteUnit ********************************************
 358 *
 359 *   NAME
 360 *       DeleteUnit -- Delete a unit.
 361 *
 362 *   SYNOPSIS
 363 *       DeleteUnit(unit)
 364 *
 365 *       VOID DeleteUnit(struct DevUnit *);
 366 *
 367 *   FUNCTION
 368 *       Deletes a unit.
 369 *
 370 *   INPUTS
 371 *       unit - Device unit (may be NULL).
 372 *
 373 *   RESULT
 374 *       None.
 375 *
 376 ****************************************************************************
 377 *
 378 */
 379
 380 VOID DeleteUnit(struct DevUnit *unit, struct DevBase *base)
 381 {
 382    UBYTE i;
 383    struct Task *task;
 384
 385    if(unit != NULL)
 386    {
 387       task = unit->task;
 388       if(task != NULL)
 389       {
 390          if((unit->flags & UNITF_TASKADDED) != 0)
 391             RemTask(task);
 392          FreeMem(task->tc_SPLower, STACK_SIZE);
 393          FreeMem(task, sizeof(struct Task));
 394       }
 395
 396       for(i = 0; i < REQUEST_QUEUE_COUNT; i++)
 397       {
 398          if(unit->request_ports[i] != NULL)
 399             FreeMem(unit->request_ports[i], sizeof(struct MsgPort));
 400       }
 401
 402       if((unit->flags & UNITF_ONLINE) != 0)   /* Needed! */
 403          GoOffline(unit, base);
 404
 405       if((unit->flags & UNITF_HAVEADAPTER) != 0)
 406          DeinitialiseAdapter(unit, base);
 407
 408       for(i = 0; i < RX_SLOT_COUNT; i++)
 409          unit->FreeDMAMem(unit->card, unit->rx_buffers[i]);
 410       unit->FreeDMAMem(unit->card, unit->tx_buffer);
 411       unit->FreeDMAMem(unit->card, unit->rx_descs[0]);
 412       unit->FreeDMAMem(unit->card, unit->tx_descs[0]);
 413
 414       FreeVec(unit->tx_requests);
 415
 416       FreeMem(unit, sizeof(struct DevUnit));
 417    }
 418
 419    return;
 420 }
 421
 422
 423
 424 /****i* rhine.device/InitialiseAdapter *************************************
 425 *
 426 *   NAME
 427 *       InitialiseAdapter
 428 *
 429 *   SYNOPSIS
 430 *       success = InitialiseAdapter(unit, reinsertion)
 431 *
 432 *       BOOL InitialiseAdapter(struct DevUnit *, BOOL);
 433 *
 434 *   FUNCTION
 435 *
 436 *   INPUTS
 437 *       unit
 438 *       reinsertion
 439 *
 440 *   RESULT
 441 *       success - Success indicator.
 442 *
 443 ****************************************************************************
 444 *
 445 */
 446
 447 BOOL InitialiseAdapter(struct DevUnit *unit, BOOL reinsertion,
 448    struct DevBase *base)
 449 {
 450    BOOL success = TRUE;
 451    UBYTE *p, eeprom_reg;
 452    UWORD i;
 453
 454    /* Reload data from EEPROM */
 455
 456    eeprom_reg = unit->ByteIn(unit->card, RH_REG_EEPROM);
 457    unit->ByteOut(unit->card, RH_REG_EEPROM,
 458       eeprom_reg | RH_REG_EEPROMF_LOAD);
 459
 460    BusyMicroDelay(1, base);
 461    while((unit->ByteIn(unit->card, RH_REG_EEPROM) & RH_REG_EEPROMF_LOAD)
 462       != 0);
 463
 464    /* Get default MAC address */
 465
 466    p = unit->default_address;
 467    for(i = 0; i < ETH_ADDRESSSIZE; i++)
 468       *p++ = unit->ByteIn(unit->card, RH_REG_ADDRESS + i);
 469
 470    /* Send reset command */
 471
 472    unit->ByteOut(unit->card, RH_REG_CONTROL + 1, RH_REG_CONTROL1F_RESET);
 473    BusyMicroDelay(110, base);
 474    while((unit->ByteIn(unit->card, RH_REG_CONTROL + 1)
 475       & RH_REG_CONTROL1F_RESET) != 0);
 476
 477    /* Disable interrupts */
 478
 479    unit->LEWordOut(unit->card, RH_REG_INTSTATUS, INT_MASK);
 480    unit->LEWordOut(unit->card, RH_REG_INTMASK, 0);
 481    if(TRUE)
 482       unit->LEWordOut(unit->card, RH_REG_MIIINTMASK, 0);
 483
 484    /* Configure MII */
 485
 486    unit->ByteOut(unit->card, RH_REG_MIICTRL,
 487       unit->ByteIn(unit->card, RH_REG_MIICTRL) | RH_REG_MIICTRLF_AUTOPOLL);
 488
 489    if(TRUE)
 490       unit->mii_phy_no = unit->ByteIn(unit->card, RH_REG_MIICONFIG)
 491          & RH_REG_MIICONFIGF_PHYADDR;
 492    else
 493       unit->mii_phy_no = 1;
 494
 495    /* Return */
 496
 497    return success;
 498 }
 499
 500
 501
 502 /****i* rhine.device/DeinitialiseAdapter ***********************************
 503 *
 504 *   NAME
 505 *       DeinitialiseAdapter
 506 *
 507 *   SYNOPSIS
 508 *       DeinitialiseAdapter(unit)
 509 *
 510 *       VOID DeinitialiseAdapter(struct DevUnit *);
 511 *
 512 *   FUNCTION
 513 *
 514 *   INPUTS
 515 *       unit
 516 *
 517 *   RESULT
 518 *       None.
 519 *
 520 ****************************************************************************
 521 *
 522 */
 523
 524 VOID DeinitialiseAdapter(struct DevUnit *unit, struct DevBase *base)
 525 {
 526    return;
 527 }
 528
 529
 530
 531 /****i* rhine.device/ConfigureAdapter **************************************
 532 *
 533 *   NAME
 534 *       ConfigureAdapter -- Set up card for transmission/reception.
 535 *
 536 *   SYNOPSIS
 537 *       ConfigureAdapter(unit)
 538 *
 539 *       VOID ConfigureAdapter(struct DevUnit *);
 540 *
 541 ****************************************************************************
 542 *
 543 */
 544
 545 VOID ConfigureAdapter(struct DevUnit *unit, struct DevBase *base)
 546 {
 547    const UBYTE *p;
 548    UWORD i;
 549
 550    /* Set MAC address */
 551
 552    p = unit->address;
 553    for(i = 0; i < ETH_ADDRESSSIZE; i++)
 554       unit->ByteOut(unit->card, RH_REG_ADDRESS + i, *p++);
 555
 556    /* Set DMA rings */
 557
 558    unit->LELongOut(unit->card, RH_REG_TXLIST, unit->tx_descs_p[0]);
 559    unit->LELongOut(unit->card, RH_REG_RXLIST, unit->rx_descs_p[0]);
 560
 561    /* Choose packet types to receive */
 562
 563    unit->LEWordOut(unit->card, RH_REG_PCIBUSCONFIG, 6);
 564    unit->ByteOut(unit->card, RH_REG_RXCONFIG,
 565       RH_REG_RXCONFIGF_BCAST | RH_REG_RXCONFIGF_MCAST);
 566
 567    /* Return */
 568
 569    return;
 570 }
 571
 572
 573
 574 /****i* rhine.device/GoOnline **********************************************
 575 *
 576 *   NAME
 577 *       GoOnline -- Enable transmission/reception.
 578 *
 579 *   SYNOPSIS
 580 *       GoOnline(unit)
 581 *
 582 *       VOID GoOnline(struct DevUnit *);
 583 *
 584 ****************************************************************************
 585 *
 586 */
 587
 588 VOID GoOnline(struct DevUnit *unit, struct DevBase *base)
 589 {
 590    /* Enable interrupts */
 591
 592    unit->flags |= UNITF_ONLINE;
 593    unit->LEWordOut(unit->card, RH_REG_INTMASK, INT_MASK);
 594
 595    /* Enable frame transmission and reception */
 596
 597    unit->LEWordOut(unit->card, RH_REG_CONTROL, RH_REG_CONTROLF_TXENABLE
 598       | RH_REG_CONTROLF_RXENABLE | RH_REG_CONTROLF_START);
 599
 600    /* Record start time and report Online event */
 601
 602    GetSysTime(&unit->stats.LastStart);
 603    ReportEvents(unit, S2EVENT_ONLINE, base);
 604
 605    return;
 606 }
 607
 608
 609
 610 /****i* rhine.device/GoOffline *********************************************
 611 *
 612 *   NAME
 613 *       GoOffline -- Disable transmission/reception.
 614 *
 615 *   SYNOPSIS
 616 *       GoOffline(unit)
 617 *
 618 *       VOID GoOffline(struct DevUnit *);
 619 *
 620 *   FUNCTION
 621 *
 622 *   INPUTS
 623 *       unit
 624 *
 625 *   RESULT
 626 *       None.
 627 *
 628 ****************************************************************************
 629 *
 630 */
 631
 632 VOID GoOffline(struct DevUnit *unit, struct DevBase *base)
 633 {
 634    unit->flags &= ~UNITF_ONLINE;
 635
 636    /* Flush pending read and write requests */
 637
 638    FlushUnit(unit, MGMT_QUEUE, S2ERR_OUTOFSERVICE, base);
 639
 640    /* Report Offline event and return */
 641
 642    ReportEvents(unit, S2EVENT_OFFLINE, base);
 643    return;
 644 }
 645
 646
 647
 648 /****i* rhine.device/AddMulticastRange *************************************
 649 *
 650 *   NAME
 651 *       AddMulticastRange
 652 *
 653 *   SYNOPSIS
 654 *       success = AddMulticastRange(unit, lower_bound, upper_bound)
 655 *
 656 *       BOOL AddMulticastRange(struct DevUnit *, UBYTE *, UBYTE *);
 657 *
 658 ****************************************************************************
 659 *
 660 */
 661
 662 BOOL AddMulticastRange(struct DevUnit *unit, const UBYTE *lower_bound,
 663    const UBYTE *upper_bound, struct DevBase *base)
 664 {
 665    struct AddressRange *range;
 666    ULONG lower_bound_left, upper_bound_left;
 667    UWORD lower_bound_right, upper_bound_right;
 668
 669    lower_bound_left = BELong(*((ULONG *)lower_bound));
 670    lower_bound_right = BEWord(*((UWORD *)(lower_bound + 4)));
 671    upper_bound_left = BELong(*((ULONG *)upper_bound));
 672    upper_bound_right = BEWord(*((UWORD *)(upper_bound + 4)));
 673
 674    range = FindMulticastRange(unit, lower_bound_left, lower_bound_right,
 675       upper_bound_left, upper_bound_right, base);
 676
 677    if(range != NULL)
 678       range->add_count++;
 679    else
 680    {
 681       range = AllocMem(sizeof(struct AddressRange), MEMF_PUBLIC);
 682       if(range != NULL)
 683       {
 684          range->lower_bound_left = lower_bound_left;
 685          range->lower_bound_right = lower_bound_right;
 686          range->upper_bound_left = upper_bound_left;
 687          range->upper_bound_right = upper_bound_right;
 688          range->add_count = 1;
 689
 690          Disable();
 691          AddTail((APTR)&unit->multicast_ranges, (APTR)range);
 692          unit->range_count++;
 693          SetMulticast(unit, base);
 694          Enable();
 695       }
 696    }
 697
 698    return range != NULL;
 699 }
 700
 701
 702
 703 /****i* rhine.device/RemMulticastRange *************************************
 704 *
 705 *   NAME
 706 *       RemMulticastRange
 707 *
 708 *   SYNOPSIS
 709 *       found = RemMulticastRange(unit, lower_bound, upper_bound)
 710 *
 711 *       BOOL RemMulticastRange(struct DevUnit *, UBYTE *, UBYTE *);
 712 *
 713 ****************************************************************************
 714 *
 715 */
 716
 717 BOOL RemMulticastRange(struct DevUnit *unit, const UBYTE *lower_bound,
 718    const UBYTE *upper_bound, struct DevBase *base)
 719 {
 720    struct AddressRange *range;
 721    ULONG lower_bound_left, upper_bound_left;
 722    UWORD lower_bound_right, upper_bound_right;
 723
 724    lower_bound_left = BELong(*((ULONG *)lower_bound));
 725    lower_bound_right = BEWord(*((UWORD *)(lower_bound + 4)));
 726    upper_bound_left = BELong(*((ULONG *)upper_bound));
 727    upper_bound_right = BEWord(*((UWORD *)(upper_bound + 4)));
 728
 729    range = FindMulticastRange(unit, lower_bound_left, lower_bound_right,
 730       upper_bound_left, upper_bound_right, base);
 731
 732    if(range != NULL)
 733    {
 734       if(--range->add_count == 0)
 735       {
 736          Disable();
 737          Remove((APTR)range);
 738          unit->range_count--;
 739          SetMulticast(unit, base);
 740          Enable();
 741          FreeMem(range, sizeof(struct AddressRange));
 742       }
 743    }
 744
 745    return range != NULL;
 746 }
 747
 748
 749
 750 /****i* rhine.device/FindMulticastRange ************************************
 751 *
 752 *   NAME
 753 *       FindMulticastRange
 754 *
 755 *   SYNOPSIS
 756 *       range = FindMulticastRange(unit, lower_bound_left,
 757 *           lower_bound_right, upper_bound_left, upper_bound_right)
 758 *
 759 *       struct AddressRange *FindMulticastRange(struct DevUnit *, ULONG,
 760 *           UWORD, ULONG, UWORD);
 761 *
 762 ****************************************************************************
 763 *
 764 */
 765
 766 static struct AddressRange *FindMulticastRange(struct DevUnit *unit,
 767    ULONG lower_bound_left, UWORD lower_bound_right, ULONG upper_bound_left,
 768    UWORD upper_bound_right, struct DevBase *base)
 769 {
 770    struct AddressRange *range, *tail;
 771    BOOL found = FALSE;
 772
 773    range = (APTR)unit->multicast_ranges.mlh_Head;
 774    tail = (APTR)&unit->multicast_ranges.mlh_Tail;
 775
 776    while(range != tail && !found)
 777    {
 778       if(lower_bound_left == range->lower_bound_left &&
 779          lower_bound_right == range->lower_bound_right &&
 780          upper_bound_left == range->upper_bound_left &&
 781          upper_bound_right == range->upper_bound_right)
 782          found = TRUE;
 783       else
 784          range = (APTR)range->node.mln_Succ;
 785    }
 786
 787    if(!found)
 788       range = NULL;
 789
 790    return range;
 791 }
 792
 793
 794
 795 /****i* rhine.device/SetMulticast ******************************************
 796 *
 797 *   NAME
 798 *       SetMulticast
 799 *
 800 *   SYNOPSIS
 801 *       SetMulticast(unit)
 802 *
 803 *       VOID SetMulticast(struct DevUnit *);
 804 *
 805 ****************************************************************************
 806 *
 807 */
 808
 809 static VOID SetMulticast(struct DevUnit *unit, struct DevBase *base)
 810 {
 811    if(!IsListEmpty(&unit->multicast_ranges))
 812    {
 813       unit->LELongOut(unit->card, RH_REG_MCASTFILTER, 0xffffffff);
 814       unit->LELongOut(unit->card, RH_REG_MCASTFILTER + 4, 0xffffffff);
 815    }
 816    else
 817    {
 818       unit->LELongOut(unit->card, RH_REG_MCASTFILTER, 0);
 819       unit->LELongOut(unit->card, RH_REG_MCASTFILTER + 4, 0);
 820    }
 821
 822    return;
 823 }
 824
 825
 826
 827 /****i* rhine.device/FindTypeStats *****************************************
 828 *
 829 *   NAME
 830 *       FindTypeStats
 831 *
 832 *   SYNOPSIS
 833 *       stats = FindTypeStats(unit, list,
 834 *           packet_type)
 835 *
 836 *       struct TypeStats *FindTypeStats(struct DevUnit *, struct MinList *,
 837 *           ULONG);
 838 *
 839 ****************************************************************************
 840 *
 841 */
 842
 843 struct TypeStats *FindTypeStats(struct DevUnit *unit, struct MinList *list,
 844    ULONG packet_type, struct DevBase *base)
 845 {
 846    struct TypeStats *stats, *tail;
 847    BOOL found = FALSE;
 848
 849    stats = (APTR)list->mlh_Head;
 850    tail = (APTR)&list->mlh_Tail;
 851
 852    while(stats != tail && !found)
 853    {
 854       if(stats->packet_type == packet_type)
 855          found = TRUE;
 856       else
 857          stats = (APTR)stats->node.mln_Succ;
 858    }
 859
 860    if(!found)
 861       stats = NULL;
 862
 863    return stats;
 864 }
 865
 866
 867
 868 /****i* rhine.device/FlushUnit *********************************************
 869 *
 870 *   NAME
 871 *       FlushUnit
 872 *
 873 *   SYNOPSIS
 874 *       FlushUnit(unit, last_queue, error)
 875 *
 876 *       VOID FlushUnit(struct DevUnit *, UBYTE, BYTE);
 877 *
 878 ****************************************************************************
 879 *
 880 */
 881
 882 VOID FlushUnit(struct DevUnit *unit, UBYTE last_queue, BYTE error,
 883    struct DevBase *base)
 884 {
 885    struct IORequest *request;
 886    UBYTE i;
 887    struct Opener *opener, *tail;
 888
 889    /* Abort queued requests */
 890
 891    for(i = 0; i <= last_queue; i++)
 892    {
 893       while((request = (APTR)GetMsg(unit->request_ports[i])) != NULL)
 894       {
 895          request->io_Error = IOERR_ABORTED;
 896          ReplyMsg((APTR)request);
 897       }
 898    }
 899
 900 #if 1
 901    opener = (APTR)unit->openers.mlh_Head;
 902    tail = (APTR)&unit->openers.mlh_Tail;
 903
 904    /* Flush every opener's read queues */
 905
 906    while(opener != tail)
 907    {
 908       while((request = (APTR)GetMsg(&opener->read_port)) != NULL)
 909       {
 910          request->io_Error = error;
 911          ReplyMsg((APTR)request);
 912       }
 913       while((request = (APTR)GetMsg(&opener->mgmt_port)) != NULL)
 914       {
 915          request->io_Error = error;
 916          ReplyMsg((APTR)request);
 917       }
 918       opener = (APTR)opener->node.mln_Succ;
 919    }
 920
 921 #else
 922    opener = request->ios2_BufferManagement;
 923    while((request = (APTR)GetMsg(&opener->read_port)) != NULL)
 924    {
 925       request->io_Error = IOERR_ABORTED;
 926       ReplyMsg((APTR)request);
 927    }
 928    while((request = (APTR)GetMsg(&opener->mgmt_port)) != NULL)
 929    {
 930       request->io_Error = IOERR_ABORTED;
 931       ReplyMsg((APTR)request);
 932    }
 933 #endif
 934
 935    /* Return */
 936
 937    return;
 938 }
 939
 940
 941
 942 /****i* rhine.device/StatusInt *********************************************
 943 *
 944 *   NAME
 945 *       StatusInt
 946 *
 947 *   SYNOPSIS
 948 *       finished = StatusInt(unit)
 949 *
 950 *       BOOL StatusInt(struct DevUnit *);
 951 *
 952 *   INPUTS
 953 *       unit - A unit of this device.
 954 *
 955 *   RESULT
 956 *       finished - Always FALSE.
 957 *
 958 ****************************************************************************
 959 *
 960 */
 961
 962 static BOOL StatusInt(REG(a1, struct DevUnit *unit), REG(a5, APTR int_code))
 963 {
 964    struct DevBase *base;
 965    UWORD ints;
 966
 967    base = unit->device;
 968    ints = unit->LEWordIn(unit->card, RH_REG_INTSTATUS);
 969
 970    if(ints != 0)
 971    {
 972       /* Acknowledge interrupts */
 973
 974       unit->LEWordOut(unit->card, RH_REG_INTSTATUS, ints);
 975
 976 /* FIXME: Need IO-sync here for PPC etc.? */
 977
 978       /* Handle interrupts */
 979
 980       if((ints & (RH_INTF_TXERR | RH_INTF_TXOK)) != 0)
 981          Cause(&unit->tx_end_int);
 982       if((ints & (RH_INTF_RXERR | RH_INTF_RXOK)) != 0)
 983          Cause(&unit->rx_int);
 984    }
 985
 986    return FALSE;
 987 }
 988
 989
 990
 991 /****i* rhine.device/RXInt *************************************************
 992 *
 993 *   NAME
 994 *       RXInt -- Soft interrupt for packet reception.
 995 *
 996 *   SYNOPSIS
 997 *       RXInt(unit)
 998 *
 999 *       VOID RXInt(struct DevUnit *);
1000 *
1001 *   FUNCTION
1002 *
1003 *   INPUTS
1004 *       unit - A unit of this device.
1005 *
1006 *   RESULT
1007 *       None.
1008 *
1009 ****************************************************************************
1010 *
1011 */
1012
1013 static VOID RXInt(REG(a1, struct DevUnit *unit), REG(a5, APTR int_code))
1014 {
1015    UWORD slot, packet_size;
1016    struct DevBase *base;
1017    ULONG rx_status, *desc, dma_size;
1018    UBYTE *buffer;
1019
1020    base = unit->device;
1021    slot = unit->rx_slot;
1022    desc = unit->rx_descs[slot];
1023
1024    dma_size = TX_DESC_SIZE;
1025    CachePostDMA(unit->rx_descs, &dma_size, 0);
1026    while(((rx_status = LELong(desc[RH_DESC_RXSTATUS]))
1027       & RH_DESC_RXSTATUSF_INUSE) == 0)
1028    {
1029       if((rx_status & RH_DESC_RXSTATUSF_OK) != 0)
1030       {
1031          packet_size = ((rx_status & RH_DESC_RXSTATUSF_LENGTH)
1032             >> RH_DESC_RXSTATUSB_LENGTH) - ETH_CRCSIZE;
1033          buffer = unit->rx_buffers[slot];
1034
1035          if(AddressFilter(unit, buffer + ETH_PACKET_DEST, base))
1036          {
1037             unit->stats.PacketsReceived++;
1038             DistributeRXPacket(unit, buffer, packet_size, base);
1039          }
1040       }
1041       else
1042       {
1043          unit->stats.BadData++;
1044          ReportEvents(unit, S2EVENT_ERROR | S2EVENT_HARDWARE | S2EVENT_RX,
1045             base);
1046       }
1047
1048       /* Mark descriptor as free for next time */
1049
1050       desc[RH_DESC_RXSTATUS] = MakeLELong(RH_DESC_RXSTATUSF_INUSE);
1051
1052       /* Get next descriptor */
1053
1054       slot = (slot + 1) % RX_SLOT_COUNT;
1055       desc = unit->rx_descs[slot];
1056    }
1057
1058    /* Return */
1059
1060    unit->rx_slot = slot;
1061    return;
1062 }
1063
1064
1065
1066 /****i* rhine.device/DistributeRXPacket ************************************
1067 *
1068 *   NAME
1069 *       DistributeRXPacket -- Send a packet to all appropriate destinations.
1070 *
1071 *   SYNOPSIS
1072 *       DistributeRXPacket(unit, frame)
1073 *
1074 *       VOID DistributeRXPacket(struct DevUnit *, UBYTE *);
1075 *
1076 ****************************************************************************
1077 *
1078 */
1079
1080 static VOID DistributeRXPacket(struct DevUnit *unit, const UBYTE *packet,
1081    UWORD packet_size, struct DevBase *base)
1082 {
1083    BOOL is_orphan = TRUE, accepted;
1084    ULONG packet_type;
1085    struct IOSana2Req *request, *request_tail;
1086    struct Opener *opener, *opener_tail;
1087    struct TypeStats *tracker;
1088
1089    /* Offer packet to every opener */
1090
1091    opener = (APTR)unit->openers.mlh_Head;
1092    opener_tail = (APTR)&unit->openers.mlh_Tail;
1093    packet_type = BEWord(*((UWORD *)(packet + ETH_PACKET_TYPE)));
1094
1095    while(opener != opener_tail)
1096    {
1097       request = (APTR)opener->read_port.mp_MsgList.lh_Head;
1098       request_tail = (APTR)&opener->read_port.mp_MsgList.lh_Tail;
1099       accepted = FALSE;
1100
1101       /* Offer packet to each request until it's accepted */
1102
1103       while(request != request_tail && !accepted)
1104       {
1105          if(request->ios2_PacketType == packet_type)
1106          {
1107             CopyPacket(unit, request, packet_size, packet_type,
1108                packet, base);
1109             accepted = TRUE;
1110          }
1111          request =
1112             (APTR)request->ios2_Req.io_Message.mn_Node.ln_Succ;
1113       }
1114
1115       if(accepted)
1116          is_orphan = FALSE;
1117       opener = (APTR)opener->node.mln_Succ;
1118    }
1119
1120    /* If packet was unwanted, give it to S2_READORPHAN request */
1121
1122    if(is_orphan)
1123    {
1124       unit->stats.UnknownTypesReceived++;
1125       if(!IsMsgPortEmpty(unit->request_ports[ADOPT_QUEUE]))
1126       {
1127          CopyPacket(unit,
1128             (APTR)unit->request_ports[ADOPT_QUEUE]->mp_MsgList.lh_Head,
1129             packet_size, packet_type, packet, base);
1130       }
1131    }
1132
1133    /* Update remaining statistics */
1134
1135    if(packet_type <= ETH_MTU)
1136       packet_type = ETH_MTU;
1137    tracker =
1138       FindTypeStats(unit, &unit->type_trackers, packet_type, base);
1139    if(tracker != NULL)
1140    {
1141       tracker->stats.PacketsReceived++;
1142       tracker->stats.BytesReceived += packet_size;
1143    }
1144
1145    return;
1146 }
1147
1148
1149
1150 /****i* rhine.device/CopyPacket ********************************************
1151 *
1152 *   NAME
1153 *       CopyPacket -- Copy packet to client's buffer.
1154 *
1155 *   SYNOPSIS
1156 *       CopyPacket(unit, request, packet_size, packet_type,
1157 *           buffer)
1158 *
1159 *       VOID CopyPacket(struct DevUnit *, struct IOSana2Req *, UWORD, UWORD,
1160 *           UBYTE *);
1161 *
1162 ****************************************************************************
1163 *
1164 */
1165
1166 static VOID CopyPacket(struct DevUnit *unit, struct IOSana2Req *request,
1167    UWORD packet_size, UWORD packet_type, const UBYTE *buffer,
1168    struct DevBase *base)
1169 {
1170    struct Opener *opener;
1171    BOOL filtered = FALSE;
1172
1173    /* Set multicast and broadcast flags */
1174
1175    request->ios2_Req.io_Flags &= ~(SANA2IOF_BCAST | SANA2IOF_MCAST);
1176    if((*((ULONG *)(buffer + ETH_PACKET_DEST)) == 0xffffffff) &&
1177       (*((UWORD *)(buffer + ETH_PACKET_DEST + 4)) == 0xffff))
1178       request->ios2_Req.io_Flags |= SANA2IOF_BCAST;
1179    else if((buffer[ETH_PACKET_DEST] & 0x1) != 0)
1180       request->ios2_Req.io_Flags |= SANA2IOF_MCAST;
1181
1182    /* Set source and destination addresses and packet type */
1183
1184    CopyMem(buffer + ETH_PACKET_SOURCE, request->ios2_SrcAddr,
1185       ETH_ADDRESSSIZE);
1186    CopyMem(buffer + ETH_PACKET_DEST, request->ios2_DstAddr,
1187       ETH_ADDRESSSIZE);
1188    request->ios2_PacketType = packet_type;
1189
1190    /* Adjust for cooked packet request */
1191
1192    if((request->ios2_Req.io_Flags & SANA2IOF_RAW) == 0)
1193    {
1194       packet_size -= ETH_PACKET_DATA;
1195       buffer += ETH_PACKET_DATA;
1196    }
1197 #ifdef USE_HACKS
1198    else
1199       packet_size += 4;   /* Needed for Shapeshifter & Fusion */
1200 #endif
1201    request->ios2_DataLength = packet_size;
1202
1203    /* Filter packet */
1204
1205    opener = request->ios2_BufferManagement;
1206    if(request->ios2_Req.io_Command == CMD_READ &&
1207       opener->filter_hook != NULL)
1208       if(!CallHookPkt(opener->filter_hook, request, (APTR)buffer))
1209          filtered = TRUE;
1210
1211    if(!filtered)
1212    {
1213       /* Copy packet into opener's buffer and reply packet */
1214
1215       if(!opener->rx_function(request->ios2_Data, (APTR)buffer,
1216          packet_size))
1217       {
1218          request->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
1219          request->ios2_WireError = S2WERR_BUFF_ERROR;
1220          ReportEvents(unit,
1221             S2EVENT_ERROR | S2EVENT_SOFTWARE | S2EVENT_BUFF | S2EVENT_RX,
1222             base);
1223       }
1224       Remove((APTR)request);
1225       ReplyMsg((APTR)request);
1226    }
1227
1228    return;
1229 }
1230
1231
1232
1233 /****i* rhine.device/AddressFilter *****************************************
1234 *
1235 *   NAME
1236 *       AddressFilter -- Determine if an RX packet should be accepted.
1237 *
1238 *   SYNOPSIS
1239 *       accept = AddressFilter(unit, address)
1240 *
1241 *       BOOL AddressFilter(struct DevUnit *, UBYTE *);
1242 *
1243 ****************************************************************************
1244 *
1245 */
1246
1247 static BOOL AddressFilter(struct DevUnit *unit, UBYTE *address,
1248    struct DevBase *base)
1249 {
1250    struct AddressRange *range, *tail;
1251    BOOL accept = TRUE;
1252    ULONG address_left;
1253    UWORD address_right;
1254
1255    /* Check whether address is unicast/broadcast or multicast */
1256
1257    address_left = BELong(*((ULONG *)address));
1258    address_right = BEWord(*((UWORD *)(address + 4)));
1259
1260    if(((address_left & 0x01000000) != 0) &&
1261       !((address_left == 0xffffffff) && (address_right == 0xffff)))
1262    {
1263       /* Check if this multicast address is wanted */
1264
1265       range = (APTR)unit->multicast_ranges.mlh_Head;
1266       tail = (APTR)&unit->multicast_ranges.mlh_Tail;
1267       accept = FALSE;
1268
1269       while((range != tail) && !accept)
1270       {
1271          if((address_left > range->lower_bound_left ||
1272             address_left == range->lower_bound_left &&
1273             address_right >= range->lower_bound_right) &&
1274             (address_left < range->upper_bound_left ||
1275             address_left == range->upper_bound_left &&
1276             address_right <= range->upper_bound_right))
1277             accept = TRUE;
1278          range = (APTR)range->node.mln_Succ;
1279       }
1280
1281       if(!accept)
1282          unit->special_stats[S2SS_ETHERNET_BADMULTICAST & 0xffff]++;
1283    }
1284
1285    return accept;
1286 }
1287
1288
1289
1290 /****i* rhine.device/TXInt *************************************************
1291 *
1292 *   NAME
1293 *       TXInt -- Soft interrupt for packet transmission.
1294 *
1295 *   SYNOPSIS
1296 *       TXInt(unit)
1297 *
1298 *       VOID TXInt(struct DevUnit *);
1299 *
1300 *   FUNCTION
1301 *
1302 *   INPUTS
1303 *       unit - A unit of this device.
1304 *
1305 *   RESULT
1306 *       None.
1307 *
1308 ****************************************************************************
1309 *
1310 */
1311
1312 static VOID TXInt(REG(a1, struct DevUnit *unit), REG(a5, APTR int_code))
1313 {
1314    struct DevBase *base;
1315    UWORD packet_size, data_size, slot, new_slot, *p, *q, i;
1316    struct IOSana2Req *request;
1317    BOOL proceed = TRUE;
1318    struct Opener *opener;
1319    ULONG wire_error, *desc, dma_size, desc_p, buffer_p, txcontrol_value;
1320    UBYTE *(*dma_tx_function)(REG(a0, APTR));
1321    BYTE error;
1322    UBYTE *buffer;
1323    struct MsgPort *port;
1324
1325    base = unit->device;
1326    port = unit->request_ports[WRITE_QUEUE];
1327
1328    while(proceed && !IsMsgPortEmpty(port))
1329    {
1330       slot = unit->tx_in_slot;
1331       new_slot = (slot + 1) % TX_SLOT_COUNT;
1332
1333       if(new_slot != unit->tx_out_slot
1334          && (unit->flags & UNITF_TXBUFFERINUSE) == 0)
1335       {
1336          error = 0;
1337
1338          /* Get request and DMA frame descriptor */
1339
1340          request = (APTR)port->mp_MsgList.lh_Head;
1341
1342          Remove((APTR)request);
1343          unit->tx_requests[slot] = request;
1344          desc = unit->tx_descs[slot];
1345          desc_p = unit->tx_descs_p[slot];
1346
1347          data_size = packet_size = request->ios2_DataLength;
1348          if((request->ios2_Req.io_Flags & SANA2IOF_RAW) == 0)
1349             packet_size += ETH_HEADERSIZE;
1350          if(packet_size < ETH_MINSIZE)
1351             packet_size = ETH_MINSIZE;
1352
1353          /* Decide if one or two descriptors are needed, and generate
1354             Ethernet header if necessary */
1355
1356          if((request->ios2_Req.io_Flags & SANA2IOF_RAW) == 0)
1357          {
1358             /* Use first descriptor for Ethernet header */
1359
1360             buffer = (UBYTE *)desc + 2 * RH_DESCSIZE;
1361             buffer_p = desc_p + 2 * RH_DESCSIZE;
1362
1363             desc[RH_DESC_TXCONTROL] =
1364                MakeLELong(RH_DESC_TXCONTROLF_FIRSTFRAG
1365                | RH_DESC_TXCONTROLF_CHAIN | ETH_HEADERSIZE);
1366             desc[RH_DESC_DATA] = MakeLELong(buffer_p);
1367             desc[RH_DESC_NEXT] = MakeLELong(desc_p + RH_DESCSIZE);
1368
1369             /* Write Ethernet header */
1370
1371             p = (UWORD *)buffer;
1372             for(i = 0, q = (UWORD *)request->ios2_DstAddr;
1373                i < ETH_ADDRESSSIZE / 2; i++)
1374                *p++ = *q++;
1375             for(i = 0, q = (UWORD *)unit->address;
1376                i < ETH_ADDRESSSIZE / 2; i++)
1377                *p++ = *q++;
1378             *p++ = MakeBEWord(request->ios2_PacketType);
1379
1380             /* Use spare second descriptor for frame data */
1381
1382             desc += RH_DESCSIZE / 4;
1383             desc_p += RH_DESCSIZE;
1384
1385             txcontrol_value = RH_DESC_TXCONTROLF_INT
1386                | RH_DESC_TXCONTROLF_LASTFRAG
1387                | RH_DESC_TXCONTROLF_CHAIN
1388                | packet_size - ETH_HEADERSIZE;
1389          }
1390          else
1391          {
1392             txcontrol_value = RH_DESC_TXCONTROLF_INT
1393                | RH_DESC_TXCONTROLF_FIRSTFRAG | RH_DESC_TXCONTROLF_LASTFRAG
1394                | RH_DESC_TXCONTROLF_CHAIN
1395                | packet_size;
1396          }
1397
1398          /* Get packet data */
1399
1400          opener = (APTR)request->ios2_BufferManagement;
1401          dma_tx_function = opener->dma_tx_function;
1402          if(dma_tx_function != NULL)
1403             buffer = dma_tx_function(request->ios2_Data);
1404          else
1405             buffer = NULL;
1406
1407          if(buffer == NULL)
1408          {
1409             buffer = unit->tx_buffer;
1410             if(opener->tx_function(buffer, request->ios2_Data,
1411                data_size))
1412             {
1413                unit->flags |= UNITF_TXBUFFERINUSE;
1414             }
1415             else
1416             {
1417                error = S2ERR_NO_RESOURCES;
1418                wire_error = S2WERR_BUFF_ERROR;
1419                ReportEvents(unit,
1420                   S2EVENT_ERROR | S2EVENT_SOFTWARE | S2EVENT_BUFF
1421                   | S2EVENT_TX, base);
1422             }
1423          }
1424          unit->tx_buffers[slot] = buffer;
1425
1426          /* Fill in descriptor for frame data */
1427
1428          if(error == 0)
1429          {
1430             dma_size = data_size;
1431             buffer_p = (ULONG)(UPINT)CachePreDMA(buffer, &dma_size,
1432                DMA_ReadFromRAM);
1433             desc[RH_DESC_TXCONTROL] = MakeLELong(txcontrol_value);
1434             desc[RH_DESC_DATA] = MakeLELong(buffer_p);
1435             desc[RH_DESC_NEXT] = MakeLELong(unit->tx_descs_p[new_slot]);
1436
1437             if((request->ios2_Req.io_Flags & SANA2IOF_RAW) == 0)
1438                desc -= RH_DESCSIZE / 4;
1439
1440             desc[RH_DESC_TXSTATUS] = MakeLELong(RH_DESC_TXSTATUSF_INUSE);
1441          }
1442
1443          if(error == 0)
1444          {
1445             /* Restart transmission if it had stopped */
1446
1447             dma_size = TX_DESC_SIZE * TX_SLOT_COUNT;
1448             CachePreDMA(unit->tx_descs, &dma_size, 0);
1449             unit->ByteOut(unit->card, RH_REG_CONTROL,
1450                unit->ByteIn(unit->card, RH_REG_CONTROL)
1451                | RH_REG_CONTROLF_TXPOLL);
1452
1453 /* FIXME: Need IO-sync here for PPC etc.? */
1454
1455             unit->tx_in_slot = new_slot;
1456          }
1457          else
1458          {
1459             /* Return failed request */
1460
1461             request->ios2_Req.io_Error = error;
1462             request->ios2_WireError = wire_error;
1463             ReplyMsg((APTR)request);
1464          }
1465       }
1466       else
1467          proceed = FALSE;
1468    }
1469
1470    if(proceed)
1471       unit->request_ports[WRITE_QUEUE]->mp_Flags = PA_SOFTINT;
1472    else
1473       unit->request_ports[WRITE_QUEUE]->mp_Flags = PA_IGNORE;
1474
1475    return;
1476 }
1477
1478
1479
1480 /****i* rhine.device/TXEndInt **********************************************
1481 *
1482 *   NAME
1483 *       TXEndInt -- Clean up after a frame has been sent.
1484 *
1485 *   SYNOPSIS
1486 *       TXEndInt(unit, int_code)
1487 *
1488 *       VOID TXEndInt(struct DevUnit *, APTR);
1489 *
1490 *   INPUTS
1491 *       unit - A unit of this device.
1492 *       int_code - Unused.
1493 *
1494 *   RESULT
1495 *       None.
1496 *
1497 ****************************************************************************
1498 *
1499 * It appears to be safe to assume that there will always be at least one
1500 * completed packet whenever this interrupt is called.
1501 *
1502 */
1503
1504 static VOID TXEndInt(REG(a1, struct DevUnit *unit), REG(a5, APTR int_code))
1505 {
1506    UWORD data_size, i = 0;
1507    UBYTE *buffer;
1508    struct DevBase *base;
1509    ULONG *desc, dma_size;
1510    BOOL proceed = TRUE;
1511
1512    /* Retire sent packets */
1513
1514    base = unit->device;
1515    dma_size = TX_DESC_SIZE * TX_SLOT_COUNT;
1516    CachePostDMA(unit->tx_descs, &dma_size, 0);
1517
1518    i = unit->tx_out_slot;
1519    while(proceed)
1520    {
1521       /* Skip to "spare" descriptor if valid */
1522
1523       desc = unit->tx_descs[i];
1524       if((desc[RH_DESC_TXCONTROL] & RH_DESC_TXCONTROLF_LASTFRAG) == 0)
1525          desc += 4;
1526
1527       /* Check that descriptor is not in use */
1528
1529       if((desc[RH_DESC_TXSTATUS] & MakeLELong(RH_DESC_TXSTATUSF_INUSE))
1530          == 0 && i != unit->tx_in_slot)
1531       {
1532          buffer = unit->tx_buffers[i];
1533          dma_size = data_size;
1534          CachePostDMA(buffer, &dma_size, DMA_ReadFromRAM);
1535
1536          /* Check if unit's buffer is now free */
1537
1538          if(buffer == unit->tx_buffer)
1539             unit->flags &= ~UNITF_TXBUFFERINUSE;
1540
1541          RetireTXSlot(unit, i, base);
1542
1543          i = (i + 1) % TX_SLOT_COUNT;
1544       }
1545       else
1546          proceed = FALSE;
1547    }
1548
1549    unit->tx_out_slot = i;
1550
1551    dma_size = TX_DESC_SIZE * TX_SLOT_COUNT;
1552    CachePreDMA(unit->tx_descs, &dma_size, 0);
1553
1554    /* Restart downloads if they had stopped */
1555
1556    if(unit->request_ports[WRITE_QUEUE]->mp_Flags == PA_IGNORE)
1557       Cause(&unit->tx_int);
1558
1559    return;
1560 }
1561
1562
1563
1564 /****i* rhine.device/RetireTXSlot ******************************************
1565 *
1566 *   NAME
1567 *       RetireTXSlot -- Reply finished TX request.
1568 *
1569 *   SYNOPSIS
1570 *       RetireTXSlot(unit, slot)
1571 *
1572 *       VOID RetireTXSlot(struct DevUnit *, UWORD);
1573 *
1574 ****************************************************************************
1575 *
1576 */
1577
1578 static VOID RetireTXSlot(struct DevUnit *unit, UWORD slot,
1579    struct DevBase *base)
1580 {
1581    UWORD frame_size;
1582    struct IOSana2Req *request;
1583    struct TypeStats *tracker;
1584
1585    /* Update statistics */
1586
1587    slot = unit->tx_out_slot;
1588    request = unit->tx_requests[slot];
1589    frame_size = request->ios2_DataLength;
1590    if((request->ios2_Req.io_Flags & SANA2IOF_RAW) == 0)
1591       frame_size += ETH_HEADERSIZE;
1592
1593    unit->stats.PacketsSent++;
1594
1595    tracker = FindTypeStats(unit, &unit->type_trackers,
1596       request->ios2_PacketType, base);
1597    if(tracker != NULL)
1598    {
1599       tracker->stats.PacketsSent++;
1600       tracker->stats.BytesSent += frame_size;
1601    }
1602
1603    /* Reply request */
1604
1605    request->ios2_Req.io_Error = 0;
1606    ReplyMsg((APTR)request);
1607
1608    return;
1609 }
1610
1611
1612
1613 /****i* rhine.device/ResetHandler ******************************************
1614 *
1615 *   NAME
1616 *       ResetHandler -- Disable hardware before a reboot.
1617 *
1618 *   SYNOPSIS
1619 *       ResetHandler(unit, int_code)
1620 *
1621 *       VOID ResetHandler(struct DevUnit *, APTR);
1622 *
1623 ****************************************************************************
1624 *
1625 */
1626
1627 static VOID ResetHandler(REG(a1, struct DevUnit *unit),
1628    REG(a6, APTR int_code))
1629 {
1630    if((unit->flags & UNITF_HAVEADAPTER) != 0)
1631    {
1632       /* Disable frame transmission and reception */
1633
1634       unit->LEWordOut(unit->card, RH_REG_CONTROL, RH_REG_CONTROLF_STOP);
1635
1636       /* Stop interrupts */
1637
1638       unit->LEWordOut(unit->card, RH_REG_INTMASK, 0);
1639
1640    }
1641
1642    return;
1643 }
1644
1645
1646
1647 /****i* rhine.device/ReportEvents ******************************************
1648 *
1649 *   NAME
1650 *       ReportEvents
1651 *
1652 *   SYNOPSIS
1653 *       ReportEvents(unit, events)
1654 *
1655 *       VOID ReportEvents(struct DevUnit *, ULONG);
1656 *
1657 *   FUNCTION
1658 *
1659 *   INPUTS
1660 *       unit - A unit of this device.
1661 *       events - A mask of events to report.
1662 *
1663 *   RESULT
1664 *       None.
1665 *
1666 ****************************************************************************
1667 *
1668 */
1669
1670 static VOID ReportEvents(struct DevUnit *unit, ULONG events,
1671    struct DevBase *base)
1672 {
1673    struct IOSana2Req *request, *tail, *next_request;
1674    struct List *list;
1675
1676    list = &unit->request_ports[EVENT_QUEUE]->mp_MsgList;
1677    next_request = (APTR)list->lh_Head;
1678    tail = (APTR)&list->lh_Tail;
1679
1680    Disable();
1681    while(next_request != tail)
1682    {
1683       request = next_request;
1684       next_request = (APTR)request->ios2_Req.io_Message.mn_Node.ln_Succ;
1685
1686       if((request->ios2_WireError & events) != 0)
1687       {
1688          request->ios2_WireError = events;
1689          Remove((APTR)request);
1690          ReplyMsg((APTR)request);
1691       }
1692    }
1693    Enable();
1694
1695    return;
1696 }
1697
1698
1699
1700 /****i* rhine.device/UnitTask **********************************************
1701 *
1702 *   NAME
1703 *       UnitTask
1704 *
1705 *   SYNOPSIS
1706 *       UnitTask(unit)
1707 *
1708 *       VOID UnitTask(struct DevUnit *);
1709 *
1710 *   FUNCTION
1711 *       Completes deferred requests, and handles card insertion and removal
1712 *       in conjunction with the relevant interrupts.
1713 *
1714 ****************************************************************************
1715 *
1716 */
1717
1718 static VOID UnitTask(struct DevUnit *unit)
1719 {
1720    struct DevBase *base;
1721    struct IORequest *request;
1722    struct MsgPort *general_port;
1723    ULONG signals = 0, wait_signals, card_removed_signal,
1724       card_inserted_signal, general_port_signal;
1725
1726    base = unit->device;
1727
1728    /* Activate general request port */
1729
1730    general_port = unit->request_ports[GENERAL_QUEUE];
1731    general_port->mp_SigTask = unit->task;
1732    general_port->mp_SigBit = AllocSignal(-1);
1733    general_port_signal = 1 << general_port->mp_SigBit;
1734    general_port->mp_Flags = PA_SIGNAL;
1735
1736    /* Allocate signals for notification of card removal and insertion */
1737
1738    card_removed_signal = unit->card_removed_signal = 1 << AllocSignal(-1);
1739    card_inserted_signal = unit->card_inserted_signal = 1 << AllocSignal(-1);
1740    wait_signals = (1 << general_port->mp_SigBit) | card_removed_signal
1741       | card_inserted_signal | SIGBREAKF_CTRL_C;
1742
1743    /* Tell ourselves to check port for old messages */
1744
1745    Signal(unit->task, general_port_signal);
1746
1747    /* Infinite loop to service requests and signals */
1748
1749    while(TRUE)
1750    {
1751       signals = Wait(wait_signals);
1752
1753       if((signals & card_inserted_signal) != 0)
1754       {
1755          if(unit->insertion_function(unit->card, base))
1756          {
1757             unit->flags |= UNITF_HAVEADAPTER;
1758             if((unit->flags & UNITF_CONFIGURED) != 0)
1759                ConfigureAdapter(unit, base);
1760             if((unit->flags & UNITF_WASONLINE) != 0)
1761             {
1762                GoOnline(unit, base);
1763                unit->flags &= ~UNITF_WASONLINE;
1764             }
1765          }
1766       }
1767
1768       if((signals & card_removed_signal) != 0)
1769       {
1770          unit->removal_function(unit->card, base);
1771          if((unit->flags & UNITF_WASONLINE) != 0)
1772             GoOffline(unit, base);
1773       }
1774
1775       if((signals & general_port_signal) != 0)
1776       {
1777          while((request = (APTR)GetMsg(general_port)) != NULL)
1778          {
1779             /* Service the request as soon as the unit is free */
1780
1781             ObtainSemaphore(&unit->access_lock);
1782             ServiceRequest((APTR)request, base);
1783          }
1784       }
1785    }
1786 }
1787
1788
1789
1790 /****i* rhine.device/ReadMII ***********************************************
1791 *
1792 *   NAME
1793 *       ReadMII -- Read a register in an MII PHY.
1794 *
1795 *   SYNOPSIS
1796 *       value = ReadMII(unit, phy_no, reg_no)
1797 *
1798 *       UWORD ReadMII(struct DevUnit *, UWORD, UWORD);
1799 *
1800 *   INPUTS
1801 *       unit - A unit of this device.
1802 *       phy_no - Index of PHY to use.
1803 *       reg_no - MII register to read.
1804 *
1805 *   RESULT
1806 *       value - Value read from MII register.
1807 *
1808 ****************************************************************************
1809 *
1810 */
1811
1812 UWORD ReadMII(struct DevUnit *unit, UWORD phy_no, UWORD reg_no,
1813    struct DevBase *base)
1814 {
1815    while((unit->ByteIn(unit->card, RH_REG_MIICTRL)
1816       & (RH_REG_MIICTRLF_READ | RH_REG_MIICTRLF_WRITE)) != 0);
1817
1818    unit->ByteOut(unit->card, RH_REG_MIICTRL, 0);
1819    unit->ByteOut(unit->card, RH_REG_MIICONFIG, phy_no);
1820    unit->ByteOut(unit->card, RH_REG_MIIREGNO, reg_no);
1821    unit->ByteOut(unit->card, RH_REG_MIICTRL, RH_REG_MIICTRLF_READ);
1822    while((unit->ByteIn(unit->card, RH_REG_MIICTRL)
1823       & (RH_REG_MIICTRLF_READ | RH_REG_MIICTRLF_WRITE)) != 0);
1824
1825    return unit->LEWordIn(unit->card, RH_REG_MIIDATA);
1826 }
1827
1828
1829