workbench/devs/networks/etherlink3/request.c

   1 /*
   2
   3 Copyright (C) 2001-2005 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/types.h>
  24 #include <exec/errors.h>
  25 #include <exec/initializers.h>
  26 #include <devices/newstyle.h>
  27
  28 #include <proto/exec.h>
  29 #include <proto/utility.h>
  30
  31 #include "device.h"
  32
  33 #include "request_protos.h"
  34 #include "unit_protos.h"
  35
  36
  37 #define KNOWN_EVENTS \
  38    (S2EVENT_ERROR | S2EVENT_TX | S2EVENT_RX | S2EVENT_ONLINE \
  39    | S2EVENT_OFFLINE | S2EVENT_BUFF | S2EVENT_HARDWARE | S2EVENT_SOFTWARE)
  40
  41
  42 static BOOL CmdInvalid(struct IOSana2Req *request, struct DevBase *base);
  43 static BOOL CmdRead(struct IOSana2Req *request, struct DevBase *base);
  44 static BOOL CmdWrite(struct IOSana2Req *request, struct DevBase *base);
  45 static BOOL CmdFlush(struct IORequest *request, struct DevBase *base);
  46 static BOOL CmdS2DeviceQuery(struct IOSana2Req *request,
  47    struct DevBase *base);
  48 static BOOL CmdGetStationAddress(struct IOSana2Req *request,
  49    struct DevBase *base);
  50 static BOOL CmdConfigInterface(struct IOSana2Req *request,
  51    struct DevBase *base);
  52 static BOOL CmdBroadcast(struct IOSana2Req *request,
  53    struct DevBase *base);
  54 static BOOL CmdTrackType(struct IOSana2Req *request,
  55    struct DevBase *base);
  56 static BOOL CmdUntrackType(struct IOSana2Req *request,
  57    struct DevBase *base);
  58 static BOOL CmdGetTypeStats(struct IOSana2Req *request,
  59    struct DevBase *base);
  60 static BOOL CmdGetSpecialStats(struct IOSana2Req *request,
  61    struct DevBase *base);
  62 static BOOL CmdGetGlobalStats(struct IOSana2Req *request,
  63    struct DevBase *base);
  64 static BOOL CmdOnEvent(struct IOSana2Req *request, struct DevBase *base);
  65 static BOOL CmdReadOrphan(struct IOSana2Req *request,
  66    struct DevBase *base);
  67 static BOOL CmdOnline(struct IOSana2Req *request, struct DevBase *base);
  68 static BOOL CmdOffline(struct IOSana2Req *request, struct DevBase *base);
  69 static BOOL CmdDeviceQuery(struct IOStdReq *request,
  70    struct DevBase *base);
  71 static BOOL CmdAddMulticastAddresses(struct IOSana2Req *request,
  72    struct DevBase *base);
  73 static BOOL CmdDelMulticastAddresses(struct IOSana2Req *request,
  74    struct DevBase *base);
  75
  76
  77 static const UWORD supported_commands[] =
  78 {
  79    CMD_READ,
  80    CMD_WRITE,
  81    CMD_FLUSH,
  82    S2_DEVICEQUERY,
  83    S2_GETSTATIONADDRESS,
  84    S2_CONFIGINTERFACE,
  85    S2_ADDMULTICASTADDRESS,
  86    S2_DELMULTICASTADDRESS,
  87    S2_MULTICAST,
  88    S2_BROADCAST,
  89    S2_TRACKTYPE,
  90    S2_UNTRACKTYPE,
  91    S2_GETTYPESTATS,
  92    S2_GETSPECIALSTATS,
  93    S2_GETGLOBALSTATS,
  94    S2_ONEVENT,
  95    S2_READORPHAN,
  96    S2_ONLINE,
  97    S2_OFFLINE,
  98    NSCMD_DEVICEQUERY,
  99    S2_ADDMULTICASTADDRESSES,
 100    S2_DELMULTICASTADDRESSES,
 101    0
 102 };
 103
 104
 105 static const struct Sana2DeviceQuery sana2_info =
 106 {
 107    0,
 108    0,
 109    0,
 110    0,
 111    ETH_ADDRESSSIZE * 8,
 112    ETH_MTU,
 113    0,
 114    S2WireType_Ethernet
 115 };
 116
 117
 118
 119 const TEXT badmulticast_name[] = "Bad multicasts";
 120 const TEXT retries_name[] = "Retries";
 121 const TEXT fifo_underruns_name[] = "Underruns";
 122
 123
 124 static const TEXT *const special_stat_names[] =
 125 {
 126    badmulticast_name,
 127    retries_name,
 128    fifo_underruns_name
 129 };
 130
 131
 132
 133 /****i* etherlink3.device/ServiceRequest ***********************************
 134 *
 135 *   NAME
 136 *       ServiceRequest -- Attempt to service a device request.
 137 *
 138 *   SYNOPSIS
 139 *       ServiceRequest(request)
 140 *
 141 *       VOID ServiceRequest(struct IORequest *);
 142 *
 143 *   FUNCTION
 144 *       Attempts to carry out a request. The relevant unit's semaphore must
 145 *       be obtained before calling this function. This function releases the
 146 *       semaphore before returning.
 147 *
 148 ****************************************************************************
 149 *
 150 */
 151
 152 VOID ServiceRequest(struct IOSana2Req *request, struct DevBase *base)
 153 {
 154    BOOL complete;
 155
 156    switch(request->ios2_Req.io_Command)
 157    {
 158    case CMD_READ:
 159       complete = CmdRead(request, base);
 160       break;
 161    case CMD_WRITE:
 162       complete = CmdWrite(request, base);
 163       break;
 164    case CMD_FLUSH:
 165       complete = CmdFlush((APTR)request, base);
 166       break;
 167    case S2_DEVICEQUERY:
 168       complete = CmdS2DeviceQuery((APTR)request, base);
 169       break;
 170    case S2_GETSTATIONADDRESS:
 171       complete = CmdGetStationAddress((APTR)request, base);
 172       break;
 173    case S2_CONFIGINTERFACE:
 174       complete = CmdConfigInterface((APTR)request, base);
 175       break;
 176    case S2_ADDMULTICASTADDRESS:
 177       complete = CmdAddMulticastAddresses((APTR)request, base);
 178       break;
 179    case S2_DELMULTICASTADDRESS:
 180       complete = CmdDelMulticastAddresses((APTR)request, base);
 181       break;
 182    case S2_MULTICAST:
 183       complete = CmdWrite((APTR)request, base);
 184       break;
 185    case S2_BROADCAST:
 186       complete = CmdBroadcast((APTR)request, base);
 187       break;
 188    case S2_TRACKTYPE:
 189       complete = CmdTrackType((APTR)request, base);
 190       break;
 191    case S2_UNTRACKTYPE:
 192       complete = CmdUntrackType((APTR)request, base);
 193       break;
 194    case S2_GETTYPESTATS:
 195       complete = CmdGetTypeStats((APTR)request, base);
 196       break;
 197    case S2_GETSPECIALSTATS:
 198       complete = CmdGetSpecialStats((APTR)request, base);
 199       break;
 200    case S2_GETGLOBALSTATS:
 201       complete = CmdGetGlobalStats((APTR)request, base);
 202       break;
 203    case S2_ONEVENT:
 204       complete = CmdOnEvent((APTR)request, base);
 205       break;
 206    case S2_READORPHAN:
 207       complete = CmdReadOrphan((APTR)request, base);
 208       break;
 209    case S2_ONLINE:
 210       complete = CmdOnline((APTR)request, base);
 211       break;
 212    case S2_OFFLINE:
 213       complete = CmdOffline((APTR)request, base);
 214       break;
 215    case NSCMD_DEVICEQUERY:
 216       complete = CmdDeviceQuery((APTR)request, base);
 217       break;
 218    case S2_ADDMULTICASTADDRESSES:
 219       complete = CmdAddMulticastAddresses((APTR)request, base);
 220       break;
 221    case S2_DELMULTICASTADDRESSES:
 222       complete = CmdDelMulticastAddresses((APTR)request, base);
 223       break;
 224    default:
 225       complete = CmdInvalid((APTR)request, base);
 226    }
 227
 228    if(complete && (request->ios2_Req.io_Flags & IOF_QUICK) == 0)
 229       ReplyMsg((APTR)request);
 230
 231    ReleaseSemaphore(&((struct DevUnit *)request->ios2_Req.io_Unit)->
 232       access_lock);
 233    return;
 234 }
 235
 236
 237
 238 /****i* etherlink3.device/CMD_INVALID **************************************
 239 *
 240 *   NAME
 241 *       CMD_INVALID -- Reject invalid commands.
 242 *
 243 *   FUNCTION
 244 *
 245 *   INPUTS
 246 *       None.
 247 *
 248 *   RESULTS
 249 *       io_Error - IOERR_NOCMD.
 250 *
 251 *   EXAMPLE
 252 *
 253 *   NOTES
 254 *
 255 *   BUGS
 256 *
 257 *   SEE ALSO
 258 *
 259 ****************************************************************************
 260 *
 261 */
 262
 263 static BOOL CmdInvalid(struct IOSana2Req *request, struct DevBase *base)
 264 {
 265    request->ios2_Req.io_Error = IOERR_NOCMD;
 266    request->ios2_WireError = S2WERR_GENERIC_ERROR;
 267
 268    return TRUE;
 269 }
 270
 271
 272
 273 /****** etherlink3.device/CMD_READ *****************************************
 274 *
 275 *   NAME
 276 *       CMD_READ -- Read data.
 277 *
 278 *   FUNCTION
 279 *
 280 *   INPUTS
 281 *       io_Flags
 282 *       ios2_PacketType
 283 *       ios2_Data
 284 *
 285 *   RESULTS
 286 *       io_Flags
 287 *       io_Error
 288 *       ios2_WireError
 289 *       ios2_SrcAddr
 290 *       ios2_DstAddr
 291 *       ios2_DataLength
 292 *       ios2_Data
 293 *
 294 *   EXAMPLE
 295 *
 296 *   NOTES
 297 *
 298 *   BUGS
 299 *
 300 *   SEE ALSO
 301 *
 302 ****************************************************************************
 303 *
 304 */
 305
 306 static BOOL CmdRead(struct IOSana2Req *request, struct DevBase *base)
 307 {
 308    struct DevUnit *unit;
 309    struct Opener *opener;
 310    BOOL complete = FALSE;
 311
 312    unit = (APTR)request->ios2_Req.io_Unit;
 313
 314    if((unit->flags & UNITF_ONLINE) != 0)
 315    {
 316       opener = request->ios2_BufferManagement;
 317       PutRequest(&opener->read_port, (APTR)request, base);
 318    }
 319    else
 320    {
 321       request->ios2_Req.io_Error = S2ERR_OUTOFSERVICE;
 322       request->ios2_WireError = S2WERR_UNIT_OFFLINE;
 323       complete = TRUE;
 324    }
 325
 326    /* Return */
 327
 328    return complete;
 329 }
 330
 331
 332
 333 /****** etherlink3.device/CMD_WRITE ****************************************
 334 *
 335 *   NAME
 336 *       CMD_WRITE -- Write data.
 337 *
 338 *   FUNCTION
 339 *
 340 *   INPUTS
 341 *       io_Flags
 342 *       ios2_DstAddr
 343 *       ios2_PacketType
 344 *       ios2_DataLength
 345 *       ios2_Data
 346 *
 347 *   RESULTS
 348 *       io_Error
 349 *       ios2_WireError
 350 *
 351 *   EXAMPLE
 352 *
 353 *   NOTES
 354 *
 355 *   BUGS
 356 *
 357 *   SEE ALSO
 358 *
 359 ****************************************************************************
 360 *
 361 */
 362
 363 /****** etherlink3.device/S2_MULTICAST *************************************
 364 *
 365 *   NAME
 366 *       S2_MULTICAST --
 367 *
 368 *   FUNCTION
 369 *
 370 *   INPUTS
 371 *       io_Flags
 372 *       ios2_DstAddr - multicast address.
 373 *       ios2_PacketType
 374 *       ios2_DataLength
 375 *       ios2_Data
 376 *
 377 *   RESULTS
 378 *       io_Error
 379 *       ios2_WireError
 380 *
 381 *   EXAMPLE
 382 *
 383 *   NOTES
 384 *
 385 *   BUGS
 386 *
 387 *   SEE ALSO
 388 *
 389 ****************************************************************************
 390 *
 391 */
 392
 393 static BOOL CmdWrite(struct IOSana2Req *request, struct DevBase *base)
 394 {
 395    struct DevUnit *unit;
 396    BYTE error = 0;
 397    ULONG wire_error;
 398    BOOL complete = FALSE;
 399
 400    /* Check request is valid */
 401
 402    unit = (APTR)request->ios2_Req.io_Unit;
 403    if((unit->flags & UNITF_ONLINE) == 0)
 404    {
 405       error = S2ERR_OUTOFSERVICE;
 406       wire_error = S2WERR_UNIT_OFFLINE;
 407    }
 408    else if((request->ios2_Req.io_Command == S2_MULTICAST) &&
 409       ((request->ios2_DstAddr[0] & 0x1) == 0))
 410    {
 411       error = S2ERR_BAD_ADDRESS;
 412       wire_error = S2WERR_BAD_MULTICAST;
 413    }
 414
 415    /* Queue request for sending */
 416
 417    if(error == 0)
 418       PutRequest(unit->request_ports[WRITE_QUEUE], (APTR)request, base);
 419    else
 420    {
 421       request->ios2_Req.io_Error = error;
 422       request->ios2_WireError = wire_error;
 423       complete = TRUE;
 424    }
 425
 426    /* Return */
 427
 428    return complete;
 429 }
 430
 431
 432
 433 /****** etherlink3.device/CMD_FLUSH ****************************************
 434 *
 435 *   NAME
 436 *       CMD_FLUSH -- .
 437 *
 438 *   FUNCTION
 439 *
 440 *   INPUTS
 441 *       None.
 442 *
 443 *   RESULTS
 444 *       io_Error
 445 *
 446 *   EXAMPLE
 447 *
 448 *   NOTES
 449 *
 450 *   BUGS
 451 *
 452 *   SEE ALSO
 453 *
 454 ****************************************************************************
 455 *
 456 */
 457
 458 static BOOL CmdFlush(struct IORequest *request, struct DevBase *base)
 459 {
 460    FlushUnit((APTR)request->io_Unit, EVENT_QUEUE, IOERR_ABORTED, base);
 461
 462    return TRUE;
 463 }
 464
 465
 466
 467 /****** etherlink3.device/S2_DEVICEQUERY ***********************************
 468 *
 469 *   NAME
 470 *       S2_DEVICEQUERY -- Query device capabilities.
 471 *
 472 *   FUNCTION
 473 *
 474 *   INPUTS
 475 *       ios2_StatData - Pointer to Sana2DeviceQuery structure.
 476 *
 477 *   RESULTS
 478 *       io_Error
 479 *       ios2_WireError
 480 *
 481 *   EXAMPLE
 482 *
 483 *   NOTES
 484 *
 485 *   BUGS
 486 *
 487 *   SEE ALSO
 488 *
 489 ****************************************************************************
 490 *
 491 */
 492
 493 static BOOL CmdS2DeviceQuery(struct IOSana2Req *request,
 494    struct DevBase *base)
 495 {
 496    struct DevUnit *unit;
 497    struct Sana2DeviceQuery *info;
 498    ULONG size_available, size;
 499
 500    /* Copy device info */
 501
 502    unit = (APTR)request->ios2_Req.io_Unit;
 503    info = request->ios2_StatData;
 504    size = size_available = info->SizeAvailable;
 505    if(size > sizeof(struct Sana2DeviceQuery))
 506       size = sizeof(struct Sana2DeviceQuery);
 507
 508    CopyMem(&sana2_info, info, size);
 509    info->BPS = unit->speed;
 510    info->SizeAvailable = size_available;
 511    info->SizeSupplied = size;
 512
 513    /* Return */
 514
 515    return TRUE;
 516 }
 517
 518
 519
 520 /****** etherlink3.device/S2_GETSTATIONADDDRESS ****************************
 521 *
 522 *   NAME
 523 *       S2_GETSTATIONADDDRESS --
 524 *
 525 *   FUNCTION
 526 *
 527 *   INPUTS
 528 *       None.
 529 *
 530 *   RESULTS
 531 *       io_Error
 532 *       ios2_WireError
 533 *       ios2_SrcAddr - current address.
 534 *       ios2_DstAddr - default address (zero if none?).
 535 *
 536 *   EXAMPLE
 537 *
 538 *   NOTES
 539 *
 540 *   BUGS
 541 *
 542 *   SEE ALSO
 543 *
 544 ****************************************************************************
 545 *
 546 */
 547
 548 static BOOL CmdGetStationAddress(struct IOSana2Req *request,
 549    struct DevBase *base)
 550 {
 551    struct DevUnit *unit;
 552
 553    /* Copy addresses */
 554
 555    unit = (APTR)request->ios2_Req.io_Unit;
 556    CopyMem(unit->address, request->ios2_SrcAddr, ETH_ADDRESSSIZE);
 557    CopyMem(unit->default_address, request->ios2_DstAddr, ETH_ADDRESSSIZE);
 558
 559    /* Return */
 560
 561    return TRUE;
 562 }
 563
 564
 565
 566 /****** etherlink3.device/S2_CONFIGINTERFACE *******************************
 567 *
 568 *   NAME
 569 *       S2_CONFIGINTERFACE --
 570 *
 571 *   FUNCTION
 572 *
 573 *   INPUTS
 574 *       ios2_SrcAddr - address to use.
 575 *
 576 *   RESULTS
 577 *       io_Error
 578 *       ios2_WireError
 579 *       ios2_SrcAddr - address used.
 580 *
 581 *   EXAMPLE
 582 *
 583 *   NOTES
 584 *
 585 *   BUGS
 586 *
 587 *   SEE ALSO
 588 *
 589 ****************************************************************************
 590 *
 591 */
 592
 593 static BOOL CmdConfigInterface(struct IOSana2Req *request,
 594    struct DevBase *base)
 595 {
 596    struct DevUnit *unit;
 597
 598    /* Configure adapter */
 599
 600    unit = (APTR)request->ios2_Req.io_Unit;
 601    if((unit->flags & UNITF_CONFIGURED) == 0)
 602    {
 603       CopyMem(request->ios2_SrcAddr, unit->address, ETH_ADDRESSSIZE);
 604       if((unit->flags & UNITF_HAVEADAPTER) != 0)
 605          ConfigureAdapter(unit, base);
 606       unit->flags |= UNITF_CONFIGURED;
 607    }
 608    else
 609    {
 610       request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 611       request->ios2_WireError = S2WERR_IS_CONFIGURED;
 612    }
 613
 614    /* Return */
 615
 616    return TRUE;
 617 }
 618
 619
 620
 621 /****** etherlink3.device/S2_BROADCAST *************************************
 622 *
 623 *   NAME
 624 *       S2_BROADCAST --
 625 *
 626 *   FUNCTION
 627 *
 628 *   INPUTS
 629 *       io_Flags
 630 *       ios2_PacketType
 631 *       ios2_DataLength
 632 *       ios2_Data
 633 *
 634 *   RESULTS
 635 *       io_Error
 636 *       ios2_WireError
 637 *
 638 *   EXAMPLE
 639 *
 640 *   NOTES
 641 *
 642 *   BUGS
 643 *
 644 *   SEE ALSO
 645 *
 646 ****************************************************************************
 647 *
 648 */
 649
 650 static BOOL CmdBroadcast(struct IOSana2Req *request,
 651    struct DevBase *base)
 652 {
 653    /* Fill in the broadcast address as destination */
 654
 655    *((ULONG *)request->ios2_DstAddr) = 0xffffffff;
 656    *((UWORD *)(request->ios2_DstAddr + 4)) = 0xffff;
 657
 658    /* Queue the write as normal */
 659
 660    return CmdWrite(request, base);
 661 }
 662
 663
 664
 665 /****** etherlink3.device/S2_TRACKTYPE *************************************
 666 *
 667 *   NAME
 668 *       S2_TRACKTYPE --
 669 *
 670 *   FUNCTION
 671 *
 672 *   INPUTS
 673 *       ios2_PacketType - packet type to start tracking.
 674 *
 675 *   RESULTS
 676 *       io_Error
 677 *       ios2_WireError
 678 *
 679 *   EXAMPLE
 680 *
 681 *   NOTES
 682 *
 683 *   BUGS
 684 *
 685 *   SEE ALSO
 686 *
 687 ****************************************************************************
 688 *
 689 */
 690
 691 static BOOL CmdTrackType(struct IOSana2Req *request,
 692    struct DevBase *base)
 693 {
 694    struct DevUnit *unit;
 695    struct Opener *opener;
 696    ULONG packet_type, wire_error;
 697    struct TypeTracker *tracker;
 698    struct TypeStats *initial_stats;
 699    BYTE error = 0;
 700
 701    unit = (APTR)request->ios2_Req.io_Unit;
 702    packet_type = request->ios2_PacketType;
 703
 704    /* Get global tracker */
 705
 706    tracker = (struct TypeTracker *)
 707       FindTypeStats(unit, &unit->type_trackers, packet_type, base);
 708
 709    if(tracker != NULL)
 710       tracker->user_count++;
 711    else
 712    {
 713       tracker =
 714          AllocMem(sizeof(struct TypeTracker), MEMF_PUBLIC | MEMF_CLEAR);
 715       if(tracker != NULL)
 716       {
 717          tracker->packet_type = packet_type;
 718          tracker->user_count = 1;
 719
 720          Disable();
 721          AddTail((APTR)&unit->type_trackers, (APTR)tracker);
 722          Enable();
 723       }
 724    }
 725
 726    /* Store initial figures for this opener */
 727
 728    opener = request->ios2_BufferManagement;
 729    initial_stats = FindTypeStats(unit, &opener->initial_stats, packet_type,
 730       base);
 731
 732    if(initial_stats != NULL)
 733    {
 734       error = S2ERR_BAD_STATE;
 735       wire_error = S2WERR_ALREADY_TRACKED;
 736    }
 737
 738    if(error == 0)
 739    {
 740       initial_stats = AllocMem(sizeof(struct TypeStats), MEMF_PUBLIC);
 741       if(initial_stats == NULL)
 742       {
 743          error = S2ERR_NO_RESOURCES;
 744          wire_error = S2WERR_GENERIC_ERROR;
 745       }
 746    }
 747
 748    if(error == 0)
 749    {
 750       CopyMem(tracker, initial_stats, sizeof(struct TypeStats));
 751       AddTail((APTR)&opener->initial_stats, (APTR)initial_stats);
 752    }
 753
 754    /* Return */
 755
 756    request->ios2_Req.io_Error = error;
 757    request->ios2_WireError = wire_error;
 758    return TRUE;
 759 }
 760
 761
 762
 763 /****** etherlink3.device/S2_UNTRACKTYPE ***********************************
 764 *
 765 *   NAME
 766 *       S2_UNTRACKTYPE --
 767 *
 768 *   FUNCTION
 769 *
 770 *   INPUTS
 771 *       ios2_PacketType - packet type to stop tracking.
 772 *
 773 *   RESULTS
 774 *       io_Error
 775 *       ios2_WireError
 776 *
 777 *   EXAMPLE
 778 *
 779 *   NOTES
 780 *
 781 *   BUGS
 782 *
 783 *   SEE ALSO
 784 *
 785 ****************************************************************************
 786 *
 787 */
 788
 789 static BOOL CmdUntrackType(struct IOSana2Req *request,
 790    struct DevBase *base)
 791 {
 792    struct DevUnit *unit;
 793    struct Opener *opener;
 794    ULONG packet_type;
 795    struct TypeTracker *tracker;
 796    struct TypeStats *initial_stats;
 797
 798    unit = (APTR)request->ios2_Req.io_Unit;
 799    packet_type = request->ios2_PacketType;
 800
 801    /* Get global tracker and initial figures */
 802
 803    tracker = (struct TypeTracker *)
 804       FindTypeStats(unit, &unit->type_trackers, packet_type, base);
 805    opener = request->ios2_BufferManagement;
 806    initial_stats = FindTypeStats(unit, &opener->initial_stats, packet_type,
 807       base);
 808
 809    /* Decrement tracker usage and free unused structures */
 810
 811    if(initial_stats != NULL)
 812    {
 813       if((--tracker->user_count) == 0)
 814       {
 815          Disable();
 816          Remove((APTR)tracker);
 817          Enable();
 818          FreeMem(tracker, sizeof(struct TypeTracker));
 819       }
 820
 821       Remove((APTR)initial_stats);
 822       FreeMem(initial_stats, sizeof(struct TypeStats));
 823    }
 824    else
 825    {
 826       request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 827       request->ios2_WireError = S2WERR_NOT_TRACKED;
 828    }
 829
 830    /* Return */
 831
 832    return TRUE;
 833 }
 834
 835
 836
 837 /****** etherlink3.device/S2_GETTYPESTATS **********************************
 838 *
 839 *   NAME
 840 *       S2_GETTYPESTATS --
 841 *
 842 *   FUNCTION
 843 *
 844 *   INPUTS
 845 *       ios2_PacketType - packet type to get statistics on.
 846 *       ios2_StatData - pointer to a Sana2PacketTypeStats structure.
 847 *
 848 *   RESULTS
 849 *       io_Error
 850 *       ios2_WireError
 851 *
 852 *   EXAMPLE
 853 *
 854 *   NOTES
 855 *
 856 *   BUGS
 857 *
 858 *   SEE ALSO
 859 *
 860 ****************************************************************************
 861 *
 862 */
 863
 864 static BOOL CmdGetTypeStats(struct IOSana2Req *request,
 865    struct DevBase *base)
 866 {
 867    struct DevUnit *unit;
 868    struct Opener *opener;
 869    ULONG packet_type;
 870    struct TypeStats *initial_stats, *tracker;
 871    struct Sana2PacketTypeStats *stats;
 872
 873    unit = (APTR)request->ios2_Req.io_Unit;
 874    packet_type = request->ios2_PacketType;
 875
 876    /* Get global tracker and initial figures */
 877
 878    tracker = FindTypeStats(unit, &unit->type_trackers, packet_type, base);
 879    opener = request->ios2_BufferManagement;
 880    initial_stats = FindTypeStats(unit, &opener->initial_stats, packet_type,
 881       base);
 882
 883    /* Copy and adjust figures */
 884
 885    if(initial_stats != NULL)
 886    {
 887       stats = request->ios2_StatData;
 888       CopyMem(&tracker->stats, stats, sizeof(struct Sana2PacketTypeStats));
 889       stats->PacketsSent -= initial_stats->stats.PacketsSent;
 890       stats->PacketsReceived -= initial_stats->stats.PacketsReceived;
 891       stats->BytesSent -= initial_stats->stats.BytesSent;
 892       stats->BytesReceived -= initial_stats->stats.BytesReceived;
 893       stats->PacketsDropped -= initial_stats->stats.PacketsDropped;
 894    }
 895    else
 896    {
 897       request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 898       request->ios2_WireError = S2WERR_NOT_TRACKED;
 899    }
 900
 901    /* Return */
 902
 903    return TRUE;
 904 }
 905
 906
 907
 908 /****** etherlink3.device/S2_GETSPECIALSTATS *******************************
 909 *
 910 *   NAME
 911 *       S2_GETSPECIALSTATS --
 912 *
 913 *   FUNCTION
 914 *
 915 *   INPUTS
 916 *       ios2_StatData - Pointer to Sana2SpecialStatHeader structure.
 917 *
 918 *   RESULTS
 919 *       io_Error
 920 *       ios2_WireError
 921 *
 922 *   EXAMPLE
 923 *
 924 *   NOTES
 925 *
 926 *   BUGS
 927 *
 928 *   SEE ALSO
 929 *
 930 ****************************************************************************
 931 *
 932 */
 933
 934 static BOOL CmdGetSpecialStats(struct IOSana2Req *request,
 935    struct DevBase *base)
 936 {
 937    struct DevUnit *unit;
 938    UWORD i, stat_count;
 939    struct Sana2SpecialStatHeader *header;
 940    struct Sana2SpecialStatRecord *record;
 941
 942    /* Fill in stats */
 943
 944    unit = (APTR)request->ios2_Req.io_Unit;
 945    header = request->ios2_StatData;
 946    record = (APTR)(header + 1);
 947
 948    stat_count = header->RecordCountMax;
 949    if(stat_count > STAT_COUNT)
 950       stat_count = STAT_COUNT;
 951
 952    for(i = 0; i < stat_count; i++)
 953    {
 954       record->Type = (S2WireType_Ethernet << 16) + i;
 955       record->Count = unit->special_stats[i];
 956       record->String = special_stat_names[i];
 957       record++;
 958    }
 959
 960    header->RecordCountSupplied = stat_count;
 961
 962    /* Return */
 963
 964    return TRUE;
 965 }
 966
 967
 968
 969 /****** etherlink3.device/S2_GETGLOBALSTATS ********************************
 970 *
 971 *   NAME
 972 *       S2_GETGLOBALSTATS --
 973 *
 974 *   FUNCTION
 975 *
 976 *   INPUTS
 977 *       ios2_StatData - Pointer to Sana2DeviceStats structure.
 978 *
 979 *   RESULTS
 980 *       io_Error
 981 *       ios2_WireError
 982 *
 983 *   EXAMPLE
 984 *
 985 *   NOTES
 986 *
 987 *   BUGS
 988 *
 989 *   SEE ALSO
 990 *
 991 ****************************************************************************
 992 *
 993 */
 994
 995 static BOOL CmdGetGlobalStats(struct IOSana2Req *request,
 996    struct DevBase *base)
 997 {
 998    struct DevUnit *unit;
 999
1000    /* Update and copy stats */
1001
1002    unit = (APTR)request->ios2_Req.io_Unit;
1003    Disable();
1004    UpdateStats(unit, base);
1005    Enable();
1006    CopyMem(&unit->stats, request->ios2_StatData,
1007       sizeof(struct Sana2DeviceStats));
1008
1009    /* Return */
1010
1011    return TRUE;
1012 }
1013
1014
1015
1016 /****** etherlink3.device/S2_ONEVENT ***************************************
1017 *
1018 *   NAME
1019 *       S2_ONEVENT --
1020 *
1021 *   FUNCTION
1022 *
1023 *   INPUTS
1024 *       ios2_WireError
1025 *
1026 *   RESULTS
1027 *       io_Error
1028 *       ios2_WireError
1029 *
1030 *   EXAMPLE
1031 *
1032 *   NOTES
1033 *
1034 *   BUGS
1035 *
1036 *   SEE ALSO
1037 *
1038 ****************************************************************************
1039 *
1040 */
1041
1042 static BOOL CmdOnEvent(struct IOSana2Req *request, struct DevBase *base)
1043 {
1044    struct DevUnit *unit;
1045    ULONG events, wanted_events;
1046    BOOL complete = FALSE;
1047
1048    /* Check if we understand the event types */
1049
1050    unit = (APTR)request->ios2_Req.io_Unit;
1051    wanted_events = request->ios2_WireError;
1052    if((wanted_events & ~KNOWN_EVENTS) != 0)
1053    {
1054       request->ios2_Req.io_Error = S2ERR_NOT_SUPPORTED;
1055       events = S2WERR_BAD_EVENT;
1056    }
1057    else
1058    {
1059       if((unit->flags & UNITF_ONLINE) != 0)
1060          events = S2EVENT_ONLINE;
1061       else
1062          events = S2EVENT_OFFLINE;
1063
1064       events &= wanted_events;
1065    }
1066
1067    /* Reply request if a wanted event has already occurred */
1068
1069    if(events != 0)
1070    {
1071       request->ios2_WireError = events;
1072       complete = TRUE;
1073    }
1074    else
1075       PutRequest(unit->request_ports[EVENT_QUEUE], (APTR)request, base);
1076
1077    /* Return */
1078
1079    return complete;
1080 }
1081
1082
1083
1084 /****** etherlink3.device/S2_READORPHAN ************************************
1085 *
1086 *   NAME
1087 *       S2_READORPHAN --
1088 *
1089 *   FUNCTION
1090 *
1091 *   INPUTS
1092 *       io_Flags
1093 *       ios2_Data
1094 *
1095 *   RESULTS
1096 *       io_Flags
1097 *       io_Error
1098 *       ios2_WireError
1099 *       ios2_PacketType - A copy of the packet's type field.
1100 *       ios2_SrcAddr
1101 *       ios2_DstAddr
1102 *       ios2_DataLength
1103 *       ios2_Data
1104 *
1105 *
1106 *   EXAMPLE
1107 *
1108 *   NOTES
1109 *
1110 *   BUGS
1111 *
1112 *   SEE ALSO
1113 *
1114 ****************************************************************************
1115 *
1116 */
1117
1118 static BOOL CmdReadOrphan(struct IOSana2Req *request,
1119    struct DevBase *base)
1120 {
1121    struct DevUnit *unit;
1122    BYTE error = 0;
1123    ULONG wire_error;
1124    BOOL complete = FALSE;
1125
1126    /* Check request is valid */
1127
1128    unit = (APTR)request->ios2_Req.io_Unit;
1129    if((unit->flags & UNITF_ONLINE) == 0)
1130    {
1131       error = S2ERR_OUTOFSERVICE;
1132       wire_error = S2WERR_UNIT_OFFLINE;
1133    }
1134
1135    /* Queue request */
1136
1137    if(error == 0)
1138       PutRequest(unit->request_ports[ADOPT_QUEUE], (APTR)request, base);
1139    else
1140    {
1141       request->ios2_Req.io_Error = error;
1142       request->ios2_WireError = wire_error;
1143       complete = TRUE;
1144    }
1145
1146    /* Return */
1147
1148    return complete;
1149 }
1150
1151
1152
1153 /****** etherlink3.device/S2_ONLINE ****************************************
1154 *
1155 *   NAME
1156 *       S2_ONLINE --
1157 *
1158 *   FUNCTION
1159 *
1160 *   INPUTS
1161 *       None.
1162 *
1163 *   RESULTS
1164 *       io_Error
1165 *       ios2_WireError
1166 *
1167 *   EXAMPLE
1168 *
1169 *   NOTES
1170 *
1171 *   BUGS
1172 *
1173 *   SEE ALSO
1174 *
1175 ****************************************************************************
1176 *
1177 */
1178
1179 static BOOL CmdOnline(struct IOSana2Req *request, struct DevBase *base)
1180 {
1181    struct DevUnit *unit;
1182    BYTE error = 0;
1183    ULONG wire_error;
1184    UWORD i;
1185
1186    /* Check request is valid */
1187
1188    unit = (APTR)request->ios2_Req.io_Unit;
1189    if((unit->flags & UNITF_CONFIGURED) == 0)
1190    {
1191       error = S2ERR_BAD_STATE;
1192       wire_error = S2WERR_NOT_CONFIGURED;
1193    }
1194    if((unit->flags & UNITF_HAVEADAPTER) == 0)
1195    {
1196       error = S2ERR_OUTOFSERVICE;
1197       wire_error = S2WERR_RCVREL_HDW_ERR;
1198    }
1199
1200    /* Clear global and special stats and put adapter back online */
1201
1202    if(error == 0 && (unit->flags & UNITF_ONLINE) == 0)
1203    {
1204       unit->stats.PacketsReceived = 0;
1205       unit->stats.PacketsSent = 0;
1206       unit->stats.BadData = 0;
1207       unit->stats.Overruns = 0;
1208       unit->stats.UnknownTypesReceived = 0;
1209       unit->stats.Reconfigurations = 0;
1210
1211       for(i = 0; i < STAT_COUNT; i++)
1212          unit->special_stats[i] = 0;
1213
1214       GoOnline(unit, base);
1215    }
1216
1217    /* Return */
1218
1219    request->ios2_Req.io_Error = error;
1220    request->ios2_WireError = wire_error;
1221    return TRUE;
1222 }
1223
1224
1225
1226 /****** etherlink3.device/S2_OFFLINE ***************************************
1227 *
1228 *   NAME
1229 *       S2_OFFLINE --
1230 *
1231 *   FUNCTION
1232 *
1233 *   INPUTS
1234 *       None.
1235 *
1236 *   RESULTS
1237 *       io_Error
1238 *       ios2_WireError
1239 *
1240 *   EXAMPLE
1241 *
1242 *   NOTES
1243 *
1244 *   BUGS
1245 *
1246 *   SEE ALSO
1247 *
1248 ****************************************************************************
1249 *
1250 */
1251
1252 static BOOL CmdOffline(struct IOSana2Req *request, struct DevBase *base)
1253 {
1254    struct DevUnit *unit;
1255
1256    /* Put adapter offline */
1257
1258    unit = (APTR)request->ios2_Req.io_Unit;
1259    if((unit->flags & UNITF_ONLINE) != 0)
1260       GoOffline(unit, base);
1261
1262    /* Return */
1263
1264    return TRUE;
1265 }
1266
1267
1268
1269 /****** etherlink3.device/NSCMD_DEVICEQUERY ********************************
1270 *
1271 *   NAME
1272 *       NSCMD_DEVICEQUERY -- Query device capabilities.
1273 *
1274 *   FUNCTION
1275 *
1276 *   INPUTS
1277 *       io_Length - ???.
1278 *       io_Data - pointer to NSDeviceQueryResult structure.
1279 *
1280 *   RESULTS
1281 *       io_Error
1282 *       io_Actual - size of structure device can handle.
1283 *
1284 *   EXAMPLE
1285 *
1286 *   NOTES
1287 *
1288 *   BUGS
1289 *
1290 *   SEE ALSO
1291 *
1292 ****************************************************************************
1293 *
1294 * Note that we have to pretend the request structure is an IOStdReq.
1295 *
1296 */
1297
1298 static BOOL CmdDeviceQuery(struct IOStdReq *request,
1299    struct DevBase *base)
1300 {
1301    struct NSDeviceQueryResult *info;
1302
1303    /* Set structure size twice */
1304
1305    info = request->io_Data;
1306    request->io_Actual = info->SizeAvailable =
1307       (ULONG)OFFSET(NSDeviceQueryResult, SupportedCommands) + sizeof(APTR);
1308
1309    /* Report device details */
1310
1311    info->DeviceType = NSDEVTYPE_SANA2;
1312    info->DeviceSubType = 0;
1313
1314    info->SupportedCommands = (APTR)supported_commands;
1315
1316    /* Return */
1317
1318    return TRUE;
1319 }
1320
1321
1322
1323 /****** etherlink3.device/S2_ADDMULTICASTADDRESS ***************************
1324 *
1325 *   NAME
1326 *       S2_ADDMULTICASTADDRESS --
1327 *
1328 *   FUNCTION
1329 *
1330 *   INPUTS
1331 *       ios2_SrcAddr - multicast address.
1332 *
1333 *   RESULTS
1334 *       io_Error
1335 *       ios2_WireError
1336 *
1337 *   EXAMPLE
1338 *
1339 *   NOTES
1340 *
1341 *   BUGS
1342 *
1343 *   SEE ALSO
1344 *
1345 ****************************************************************************
1346 *
1347 */
1348
1349 /****** etherlink3.device/S2_ADDMULTICASTADDRESSES *************************
1350 *
1351 *   NAME
1352 *       S2_ADDMULTICASTADDRESSES --
1353 *
1354 *   FUNCTION
1355 *
1356 *   INPUTS
1357 *       ios2_SrcAddr - lower bound.
1358 *       ios2_DstAddr - upper bound.
1359 *
1360 *   RESULTS
1361 *       io_Error
1362 *       ios2_WireError
1363 *
1364 *   EXAMPLE
1365 *
1366 *   NOTES
1367 *
1368 *   BUGS
1369 *
1370 *   SEE ALSO
1371 *
1372 ****************************************************************************
1373 *
1374 */
1375
1376 static BOOL CmdAddMulticastAddresses(struct IOSana2Req *request,
1377    struct DevBase *base)
1378 {
1379    struct DevUnit *unit;
1380    UBYTE *lower_bound, *upper_bound;
1381
1382    unit = (APTR)request->ios2_Req.io_Unit;
1383
1384    lower_bound = request->ios2_SrcAddr;
1385    if(request->ios2_Req.io_Command == S2_ADDMULTICASTADDRESS)
1386       upper_bound = lower_bound;
1387    else
1388       upper_bound = request->ios2_DstAddr;
1389
1390    if(!AddMulticastRange(unit, lower_bound, upper_bound, base))
1391    {
1392       request->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
1393       request->ios2_WireError = S2WERR_GENERIC_ERROR;
1394    }
1395
1396    /* Return */
1397
1398    return TRUE;
1399 }
1400
1401
1402
1403 /****** etherlink3.device/S2_DELMULTICASTADDRESS ***************************
1404 *
1405 *   NAME
1406 *       S2_DELMULTICASTADDRESS --
1407 *
1408 *   FUNCTION
1409 *
1410 *   INPUTS
1411 *       ios2_SrcAddr - multicast address.
1412 *
1413 *   RESULTS
1414 *       io_Error
1415 *       ios2_WireError
1416 *
1417 *   EXAMPLE
1418 *
1419 *   NOTES
1420 *
1421 *   BUGS
1422 *
1423 *   SEE ALSO
1424 *
1425 ****************************************************************************
1426 *
1427 */
1428
1429 /****** etherlink3.device/S2_DELMULTICASTADDRESSES *************************
1430 *
1431 *   NAME
1432 *       S2_DELMULTICASTADDRESSES --
1433 *
1434 *   FUNCTION
1435 *
1436 *   INPUTS
1437 *       ios2_SrcAddr - lower bound.
1438 *       ios2_DstAddr - upper bound.
1439 *
1440 *   RESULTS
1441 *       io_Error
1442 *       ios2_WireError
1443 *
1444 *   EXAMPLE
1445 *
1446 *   NOTES
1447 *
1448 *   BUGS
1449 *
1450 *   SEE ALSO
1451 *
1452 ****************************************************************************
1453 *
1454 */
1455
1456 static BOOL CmdDelMulticastAddresses(struct IOSana2Req *request,
1457    struct DevBase *base)
1458 {
1459    struct DevUnit *unit;
1460    UBYTE *lower_bound, *upper_bound;
1461
1462    unit = (APTR)request->ios2_Req.io_Unit;
1463
1464    lower_bound = request->ios2_SrcAddr;
1465    if(request->ios2_Req.io_Command == S2_DELMULTICASTADDRESS)
1466       upper_bound = lower_bound;
1467    else
1468       upper_bound = request->ios2_DstAddr;
1469
1470    if(!RemMulticastRange(unit, lower_bound, upper_bound, base))
1471    {
1472       request->ios2_Req.io_Error = S2ERR_BAD_STATE;
1473       request->ios2_WireError = S2WERR_BAD_MULTICAST;
1474    }
1475
1476    /* Return */
1477
1478    return TRUE;
1479 }
1480
1481
1482
1483 /****i* etherlink3.device/PutRequest ***************************************
1484 *
1485 *   NAME
1486 *       PutRequest -- .
1487 *
1488 *   SYNOPSIS
1489 *       PutRequest(port, request)
1490 *
1491 *       VOID PutRequest(struct MsgPort *, struct IORequest *);
1492 *
1493 *   FUNCTION
1494 *
1495 *   INPUTS
1496 *       port
1497 *       request
1498 *
1499 *   RESULT
1500 *       None.
1501 *
1502 *   EXAMPLE
1503 *
1504 *   NOTES
1505 *
1506 *   BUGS
1507 *
1508 *   SEE ALSO
1509 *
1510 ****************************************************************************
1511 *
1512 */
1513
1514 VOID PutRequest(struct MsgPort *port, struct IORequest *request,
1515    struct DevBase *base)
1516 {
1517    request->io_Flags &= ~IOF_QUICK;
1518    PutMsg(port, (APTR)request);
1519
1520    return;
1521 }
1522
1523
1524