workbench/devs/networks/intelpro100/request.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/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 static const struct Sana2DeviceQuery sana2_info =
 105 {
 106    0,
 107    0,
 108    0,
 109    0,
 110    ETH_ADDRESSSIZE * 8,
 111    ETH_MTU,
 112    0,
 113    S2WireType_Ethernet
 114 };
 115
 116 const TEXT badmulticast_name[] = "Bad multicasts";
 117 const TEXT retries_name[] = "Retries";
 118 const TEXT fifo_underruns_name[] = "Underruns";
 119
 120 const TEXT *const special_stat_names[] =
 121 {
 122    badmulticast_name,
 123    retries_name,
 124    fifo_underruns_name
 125 };
 126
 127
 128
 129 /****i* intelpro100.device/ServiceRequest **********************************
 130 *
 131 *   NAME
 132 *       ServiceRequest -- Attempt to service a device request.
 133 *
 134 *   SYNOPSIS
 135 *       ServiceRequest(request)
 136 *
 137 *       VOID ServiceRequest(struct IORequest *);
 138 *
 139 *   FUNCTION
 140 *       Attempts to carry out a request. The relevant unit's semaphore must
 141 *       be obtained before calling this function. This function releases the
 142 *       semaphore before returning.
 143 *
 144 *   INPUTS
 145 *       request - The request to service.
 146 *
 147 *   RESULT
 148 *       None.
 149 *
 150 ****************************************************************************
 151 *
 152 */
 153
 154 VOID ServiceRequest(struct IOSana2Req *request, struct DevBase *base)
 155 {
 156    BOOL complete;
 157
 158    switch(request->ios2_Req.io_Command)
 159    {
 160    case CMD_READ:
 161       complete = CmdRead(request, base);
 162       break;
 163    case CMD_WRITE:
 164       complete = CmdWrite(request, base);
 165       break;
 166    case CMD_FLUSH:
 167       complete = CmdFlush((APTR)request, base);
 168       break;
 169    case S2_DEVICEQUERY:
 170       complete = CmdS2DeviceQuery((APTR)request, base);
 171       break;
 172    case S2_GETSTATIONADDRESS:
 173       complete = CmdGetStationAddress((APTR)request, base);
 174       break;
 175    case S2_CONFIGINTERFACE:
 176       complete = CmdConfigInterface((APTR)request, base);
 177       break;
 178    case S2_ADDMULTICASTADDRESS:
 179       complete = CmdAddMulticastAddresses((APTR)request, base);
 180       break;
 181    case S2_DELMULTICASTADDRESS:
 182       complete = CmdDelMulticastAddresses((APTR)request, base);
 183       break;
 184    case S2_MULTICAST:
 185       complete = CmdWrite((APTR)request, base);
 186       break;
 187    case S2_BROADCAST:
 188       complete = CmdBroadcast((APTR)request, base);
 189       break;
 190    case S2_TRACKTYPE:
 191       complete = CmdTrackType((APTR)request, base);
 192       break;
 193    case S2_UNTRACKTYPE:
 194       complete = CmdUntrackType((APTR)request, base);
 195       break;
 196    case S2_GETTYPESTATS:
 197       complete = CmdGetTypeStats((APTR)request, base);
 198       break;
 199    case S2_GETSPECIALSTATS:
 200       complete = CmdGetSpecialStats((APTR)request, base);
 201       break;
 202    case S2_GETGLOBALSTATS:
 203       complete = CmdGetGlobalStats((APTR)request, base);
 204       break;
 205    case S2_ONEVENT:
 206       complete = CmdOnEvent((APTR)request, base);
 207       break;
 208    case S2_READORPHAN:
 209       complete = CmdReadOrphan((APTR)request, base);
 210       break;
 211    case S2_ONLINE:
 212       complete = CmdOnline((APTR)request, base);
 213       break;
 214    case S2_OFFLINE:
 215       complete = CmdOffline((APTR)request, base);
 216       break;
 217    case NSCMD_DEVICEQUERY:
 218       complete = CmdDeviceQuery((APTR)request, base);
 219       break;
 220    case S2_ADDMULTICASTADDRESSES:
 221       complete = CmdAddMulticastAddresses((APTR)request, base);
 222       break;
 223    case S2_DELMULTICASTADDRESSES:
 224       complete = CmdDelMulticastAddresses((APTR)request, base);
 225       break;
 226    default:
 227       complete = CmdInvalid((APTR)request, base);
 228    }
 229
 230    if(complete && ((request->ios2_Req.io_Flags & IOF_QUICK) == 0))
 231       ReplyMsg((APTR)request);
 232
 233    ReleaseSemaphore(&((struct DevUnit *)request->ios2_Req.io_Unit)->
 234       access_lock);
 235    return;
 236 }
 237
 238
 239
 240 /****i* intelpro100.device/CMD_INVALID *************************************
 241 *
 242 *   NAME
 243 *       CMD_INVALID -- Reject invalid commands.
 244 *
 245 *   FUNCTION
 246 *       See SANA-II documentation.
 247 *
 248 ****************************************************************************
 249 *
 250 */
 251
 252 static BOOL CmdInvalid(struct IOSana2Req *request, struct DevBase *base)
 253 {
 254    request->ios2_Req.io_Error = IOERR_NOCMD;
 255    request->ios2_WireError = S2WERR_GENERIC_ERROR;
 256
 257    return TRUE;
 258 }
 259
 260
 261
 262 /****** intelpro100.device/CMD_READ ****************************************
 263 *
 264 *   NAME
 265 *       CMD_READ -- Read data.
 266 *
 267 *   FUNCTION
 268 *       See SANA-II documentation.
 269 *
 270 ****************************************************************************
 271 *
 272 */
 273
 274 static BOOL CmdRead(struct IOSana2Req *request, struct DevBase *base)
 275 {
 276    struct DevUnit *unit;
 277    struct Opener *opener;
 278    BOOL complete = FALSE;
 279
 280    unit = (APTR)request->ios2_Req.io_Unit;
 281
 282    if((unit->flags & UNITF_ONLINE) != 0)
 283    {
 284       opener = request->ios2_BufferManagement;
 285       PutRequest(&opener->read_port, (APTR)request, base);
 286    }
 287    else
 288    {
 289       request->ios2_Req.io_Error = S2ERR_OUTOFSERVICE;
 290       request->ios2_WireError = S2WERR_UNIT_OFFLINE;
 291       complete = TRUE;
 292    }
 293
 294    /* Return */
 295
 296    return complete;
 297 }
 298
 299
 300
 301 /****** intelpro100.device/CMD_WRITE ***************************************
 302 *
 303 *   NAME
 304 *       CMD_WRITE -- Write data.
 305 *
 306 *   FUNCTION
 307 *       See SANA-II documentation.
 308 *
 309 ****************************************************************************
 310 *
 311 */
 312
 313 /****** intelpro100.device/S2_MULTICAST ************************************
 314 *
 315 *   NAME
 316 *       S2_MULTICAST
 317 *
 318 *   FUNCTION
 319 *       See SANA-II documentation.
 320 *
 321 ****************************************************************************
 322 *
 323 */
 324
 325 static BOOL CmdWrite(struct IOSana2Req *request, struct DevBase *base)
 326 {
 327    struct DevUnit *unit;
 328    BYTE error = 0;
 329    ULONG wire_error;
 330    BOOL complete = FALSE;
 331
 332    /* Check request is valid */
 333
 334    unit = (APTR)request->ios2_Req.io_Unit;
 335    if((unit->flags & UNITF_ONLINE) == 0)
 336    {
 337       error = S2ERR_OUTOFSERVICE;
 338       wire_error = S2WERR_UNIT_OFFLINE;
 339    }
 340    else if((request->ios2_Req.io_Command == S2_MULTICAST) &&
 341       ((request->ios2_DstAddr[0] & 0x1) == 0))
 342    {
 343       error = S2ERR_BAD_ADDRESS;
 344       wire_error = S2WERR_BAD_MULTICAST;
 345    }
 346
 347    /* Queue request for sending */
 348
 349    if(error == 0)
 350       PutRequest(unit->request_ports[WRITE_QUEUE], (APTR)request, base);
 351    else
 352    {
 353       request->ios2_Req.io_Error = error;
 354       request->ios2_WireError = wire_error;
 355       complete = TRUE;
 356    }
 357
 358    /* Return */
 359
 360    return complete;
 361 }
 362
 363
 364
 365 /****** intelpro100.device/CMD_FLUSH ***************************************
 366 *
 367 *   NAME
 368 *       CMD_FLUSH
 369 *
 370 *   FUNCTION
 371 *       See SANA-II documentation.
 372 *
 373 ****************************************************************************
 374 *
 375 */
 376
 377 static BOOL CmdFlush(struct IORequest *request, struct DevBase *base)
 378 {
 379    FlushUnit((APTR)request->io_Unit, EVENT_QUEUE, IOERR_ABORTED, base);
 380
 381    return TRUE;
 382 }
 383
 384
 385
 386 /****** intelpro100.device/S2_DEVICEQUERY **********************************
 387 *
 388 *   NAME
 389 *       S2_DEVICEQUERY -- Query device capabilities.
 390 *
 391 *   FUNCTION
 392 *       See SANA-II documentation.
 393 *
 394 ****************************************************************************
 395 *
 396 */
 397
 398 static BOOL CmdS2DeviceQuery(struct IOSana2Req *request,
 399    struct DevBase *base)
 400 {
 401    struct DevUnit *unit;
 402    struct Sana2DeviceQuery *info;
 403    ULONG size_available, size;
 404
 405    /* Copy device info */
 406
 407    unit = (APTR)request->ios2_Req.io_Unit;
 408    info = request->ios2_StatData;
 409    size = size_available = info->SizeAvailable;
 410    if(size > sizeof(struct Sana2DeviceQuery))
 411       size = sizeof(struct Sana2DeviceQuery);
 412
 413    CopyMem(&sana2_info, info, size);
 414    info->BPS = unit->speed;
 415
 416    info->SizeAvailable = size_available;
 417    info->SizeSupplied = size;
 418
 419    /* Return */
 420
 421    return TRUE;
 422 }
 423
 424
 425
 426 /****** intelpro100.device/S2_GETSTATIONADDDRESS ***************************
 427 *
 428 *   NAME
 429 *       S2_GETSTATIONADDDRESS
 430 *
 431 *   FUNCTION
 432 *       See SANA-II documentation.
 433 *
 434 ****************************************************************************
 435 *
 436 */
 437
 438 static BOOL CmdGetStationAddress(struct IOSana2Req *request,
 439    struct DevBase *base)
 440 {
 441    struct DevUnit *unit;
 442
 443    /* Copy addresses */
 444
 445    unit = (APTR)request->ios2_Req.io_Unit;
 446    CopyMem(unit->address, request->ios2_SrcAddr, ETH_ADDRESSSIZE);
 447    CopyMem(unit->default_address, request->ios2_DstAddr, ETH_ADDRESSSIZE);
 448
 449    /* Return */
 450
 451    return TRUE;
 452 }
 453
 454
 455
 456 /****** intelpro100.device/S2_CONFIGINTERFACE ******************************
 457 *
 458 *   NAME
 459 *       S2_CONFIGINTERFACE --
 460 *
 461 *   FUNCTION
 462 *       See SANA-II documentation.
 463 *
 464 ****************************************************************************
 465 *
 466 */
 467
 468 static BOOL CmdConfigInterface(struct IOSana2Req *request,
 469    struct DevBase *base)
 470 {
 471    struct DevUnit *unit;
 472
 473    /* Configure adapter */
 474
 475    unit = (APTR)request->ios2_Req.io_Unit;
 476    if((unit->flags & UNITF_CONFIGURED) == 0)
 477    {
 478       CopyMem(request->ios2_SrcAddr, unit->address, ETH_ADDRESSSIZE);
 479       if((unit->flags & UNITF_HAVEADAPTER) != 0)
 480          ConfigureAdapter(unit, base);
 481       unit->flags |= UNITF_CONFIGURED;
 482    }
 483    else
 484    {
 485       request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 486       request->ios2_WireError = S2WERR_IS_CONFIGURED;
 487    }
 488
 489    /* Return */
 490
 491    return TRUE;
 492 }
 493
 494
 495
 496 /****** intelpro100.device/S2_BROADCAST ************************************
 497 *
 498 *   NAME
 499 *       S2_BROADCAST
 500 *
 501 *   FUNCTION
 502 *       See SANA-II documentation.
 503 *
 504 ****************************************************************************
 505 *
 506 */
 507
 508 static BOOL CmdBroadcast(struct IOSana2Req *request,
 509    struct DevBase *base)
 510 {
 511    UWORD i;
 512
 513    /* Fill in the broadcast address as destination */
 514
 515    for(i = 0; i < ETH_ADDRESSSIZE; i++)
 516       request->ios2_DstAddr[i] = 0xff;
 517
 518    /* Queue the write as normal */
 519
 520    return CmdWrite(request, base);
 521 }
 522
 523
 524
 525 /****** intelpro100.device/S2_TRACKTYPE ************************************
 526 *
 527 *   NAME
 528 *       S2_TRACKTYPE
 529 *
 530 *   FUNCTION
 531 *       See SANA-II documentation.
 532 *
 533 ****************************************************************************
 534 *
 535 */
 536
 537 static BOOL CmdTrackType(struct IOSana2Req *request,
 538    struct DevBase *base)
 539 {
 540    struct DevUnit *unit;
 541    struct Opener *opener;
 542    ULONG packet_type, wire_error;
 543    struct TypeTracker *tracker;
 544    struct TypeStats *initial_stats;
 545    BYTE error = 0;
 546
 547    unit = (APTR)request->ios2_Req.io_Unit;
 548    packet_type = request->ios2_PacketType;
 549
 550    /* Get global tracker */
 551
 552    tracker = (struct TypeTracker *)
 553       FindTypeStats(unit, &unit->type_trackers, packet_type, base);
 554
 555    if(tracker != NULL)
 556       tracker->user_count++;
 557    else
 558    {
 559       tracker =
 560          AllocMem(sizeof(struct TypeTracker), MEMF_PUBLIC | MEMF_CLEAR);
 561       if(tracker != NULL)
 562       {
 563          tracker->packet_type = packet_type;
 564          tracker->user_count = 1;
 565
 566          Disable();
 567          AddTail((APTR)&unit->type_trackers, (APTR)tracker);
 568          Enable();
 569       }
 570    }
 571
 572    /* Store initial figures for this opener */
 573
 574    opener = request->ios2_BufferManagement;
 575    initial_stats = FindTypeStats(unit, &opener->initial_stats, packet_type,
 576       base);
 577
 578    if(initial_stats != NULL)
 579    {
 580       error = S2ERR_BAD_STATE;
 581       wire_error = S2WERR_ALREADY_TRACKED;
 582    }
 583
 584    if(error == 0)
 585    {
 586       initial_stats = AllocMem(sizeof(struct TypeStats), MEMF_PUBLIC);
 587       if(initial_stats == NULL)
 588       {
 589          error = S2ERR_NO_RESOURCES;
 590          wire_error = S2WERR_GENERIC_ERROR;
 591       }
 592    }
 593
 594    if(error == 0)
 595    {
 596       CopyMem(tracker, initial_stats, sizeof(struct TypeStats));
 597       AddTail((APTR)&opener->initial_stats, (APTR)initial_stats);
 598    }
 599
 600    /* Return */
 601
 602    request->ios2_Req.io_Error = error;
 603    request->ios2_WireError = wire_error;
 604    return TRUE;
 605 }
 606
 607
 608
 609 /****** intelpro100.device/S2_UNTRACKTYPE **********************************
 610 *
 611 *   NAME
 612 *       S2_UNTRACKTYPE
 613 *
 614 *   FUNCTION
 615 *       See SANA-II documentation.
 616 *
 617 ****************************************************************************
 618 *
 619 */
 620
 621 static BOOL CmdUntrackType(struct IOSana2Req *request,
 622    struct DevBase *base)
 623 {
 624    struct DevUnit *unit;
 625    struct Opener *opener;
 626    ULONG packet_type;
 627    struct TypeTracker *tracker;
 628    struct TypeStats *initial_stats;
 629
 630    unit = (APTR)request->ios2_Req.io_Unit;
 631    packet_type = request->ios2_PacketType;
 632
 633    /* Get global tracker and initial figures */
 634
 635    tracker = (struct TypeTracker *)
 636       FindTypeStats(unit, &unit->type_trackers, packet_type, base);
 637    opener = request->ios2_BufferManagement;
 638    initial_stats = FindTypeStats(unit, &opener->initial_stats, packet_type,
 639       base);
 640
 641    /* Decrement tracker usage and free unused structures */
 642
 643    if(initial_stats != NULL)
 644    {
 645       if((--tracker->user_count) == 0)
 646       {
 647          Disable();
 648          Remove((APTR)tracker);
 649          Enable();
 650          FreeMem(tracker, sizeof(struct TypeTracker));
 651       }
 652
 653       Remove((APTR)initial_stats);
 654       FreeMem(initial_stats, sizeof(struct TypeStats));
 655    }
 656    else
 657    {
 658       request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 659       request->ios2_WireError = S2WERR_NOT_TRACKED;
 660    }
 661
 662    /* Return */
 663
 664    return TRUE;
 665 }
 666
 667
 668
 669 /****** intelpro100.device/S2_GETTYPESTATS *********************************
 670 *
 671 *   NAME
 672 *       S2_GETTYPESTATS
 673 *
 674 *   FUNCTION
 675 *       See SANA-II documentation.
 676 *
 677 ****************************************************************************
 678 *
 679 */
 680
 681 static BOOL CmdGetTypeStats(struct IOSana2Req *request,
 682    struct DevBase *base)
 683 {
 684    struct DevUnit *unit;
 685    struct Opener *opener;
 686    ULONG packet_type;
 687    struct TypeStats *initial_stats, *tracker;
 688    struct Sana2PacketTypeStats *stats;
 689
 690    unit = (APTR)request->ios2_Req.io_Unit;
 691    packet_type = request->ios2_PacketType;
 692
 693    /* Get global tracker and initial figures */
 694
 695    tracker = FindTypeStats(unit, &unit->type_trackers, packet_type, base);
 696    opener = request->ios2_BufferManagement;
 697    initial_stats = FindTypeStats(unit, &opener->initial_stats, packet_type,
 698       base);
 699
 700    /* Copy and adjust figures */
 701
 702    if(initial_stats != NULL)
 703    {
 704       stats = request->ios2_StatData;
 705       CopyMem(&tracker->stats, stats, sizeof(struct Sana2PacketTypeStats));
 706       stats->PacketsSent -= initial_stats->stats.PacketsSent;
 707       stats->PacketsReceived -= initial_stats->stats.PacketsReceived;
 708       stats->BytesSent -= initial_stats->stats.BytesSent;
 709       stats->BytesReceived -= initial_stats->stats.BytesReceived;
 710       stats->PacketsDropped -= initial_stats->stats.PacketsDropped;
 711    }
 712    else
 713    {
 714       request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 715       request->ios2_WireError = S2WERR_NOT_TRACKED;
 716    }
 717
 718    /* Return */
 719
 720    return TRUE;
 721 }
 722
 723
 724
 725 /****** intelpro100.device/S2_GETSPECIALSTATS ******************************
 726 *
 727 *   NAME
 728 *       S2_GETSPECIALSTATS
 729 *
 730 *   FUNCTION
 731 *       See SANA-II documentation.
 732 *
 733 ****************************************************************************
 734 *
 735 */
 736
 737 static BOOL CmdGetSpecialStats(struct IOSana2Req *request,
 738    struct DevBase *base)
 739 {
 740    struct DevUnit *unit;
 741    UWORD i, stat_count;
 742    struct Sana2SpecialStatHeader *header;
 743    struct Sana2SpecialStatRecord *record;
 744
 745    /* Update and fill in stats */
 746
 747    unit = (APTR)request->ios2_Req.io_Unit;
 748    if((unit->flags & UNITF_ONLINE) != 0)
 749    {
 750       Disable();
 751       UpdateStats(unit, base);
 752       Enable();
 753    }
 754
 755    header = request->ios2_StatData;
 756    record = (APTR)(header + 1);
 757
 758    stat_count = header->RecordCountMax;
 759    if(stat_count > SPECIAL_STAT_COUNT)
 760       stat_count = SPECIAL_STAT_COUNT;
 761
 762    for(i = 0; i < stat_count; i++)
 763    {
 764       record->Type = (S2WireType_Ethernet << 16) + i;
 765       record->Count = unit->special_stats[i];
 766       record->String = special_stat_names[i];
 767       record++;
 768    }
 769
 770    header->RecordCountSupplied = stat_count;
 771
 772    /* Return */
 773
 774    return TRUE;
 775 }
 776
 777
 778
 779 /****** intelpro100.device/S2_GETGLOBALSTATS *******************************
 780 *
 781 *   NAME
 782 *       S2_GETGLOBALSTATS
 783 *
 784 *   FUNCTION
 785 *       See SANA-II documentation.
 786 *
 787 ****************************************************************************
 788 *
 789 */
 790
 791 static BOOL CmdGetGlobalStats(struct IOSana2Req *request,
 792    struct DevBase *base)
 793 {
 794    struct DevUnit *unit;
 795
 796    /* Update and copy stats */
 797
 798    unit = (APTR)request->ios2_Req.io_Unit;
 799    if((unit->flags & UNITF_ONLINE) != 0)
 800    {
 801       Disable();
 802       UpdateStats(unit, base);
 803       Enable();
 804    }
 805    CopyMem(&unit->stats, request->ios2_StatData,
 806       sizeof(struct Sana2DeviceStats));
 807
 808    /* Return */
 809
 810    return TRUE;
 811 }
 812
 813
 814
 815 /****** intelpro100.device/S2_ONEVENT **************************************
 816 *
 817 *   NAME
 818 *       S2_ONEVENT --
 819 *
 820 *   FUNCTION
 821 *       See SANA-II documentation.
 822 *
 823 ****************************************************************************
 824 *
 825 */
 826
 827 static BOOL CmdOnEvent(struct IOSana2Req *request, struct DevBase *base)
 828 {
 829    struct DevUnit *unit;
 830    ULONG events, wanted_events;
 831    BOOL complete = FALSE;
 832
 833    /* Check if we understand the event types */
 834
 835    unit = (APTR)request->ios2_Req.io_Unit;
 836    wanted_events = request->ios2_WireError;
 837    if((wanted_events & ~KNOWN_EVENTS) != 0)
 838    {
 839       request->ios2_Req.io_Error = S2ERR_NOT_SUPPORTED;
 840       events = S2WERR_BAD_EVENT;
 841    }
 842    else
 843    {
 844       if((unit->flags & UNITF_ONLINE) != 0)
 845          events = S2EVENT_ONLINE;
 846       else
 847          events = S2EVENT_OFFLINE;
 848
 849       events &= wanted_events;
 850    }
 851
 852    /* Reply request if a wanted event has already occurred */
 853
 854    if(events != 0)
 855    {
 856       request->ios2_WireError = events;
 857       complete = TRUE;
 858    }
 859    else
 860       PutRequest(unit->request_ports[EVENT_QUEUE], (APTR)request, base);
 861
 862    /* Return */
 863
 864    return complete;
 865 }
 866
 867
 868
 869 /****** intelpro100.device/S2_READORPHAN ***********************************
 870 *
 871 *   NAME
 872 *       S2_READORPHAN
 873 *
 874 *   FUNCTION
 875 *       See SANA-II documentation.
 876 *
 877 ****************************************************************************
 878 *
 879 */
 880
 881 static BOOL CmdReadOrphan(struct IOSana2Req *request,
 882    struct DevBase *base)
 883 {
 884    struct DevUnit *unit;
 885    BYTE error = 0;
 886    ULONG wire_error;
 887    BOOL complete = FALSE;
 888
 889    /* Check request is valid */
 890
 891    unit = (APTR)request->ios2_Req.io_Unit;
 892    if((unit->flags & UNITF_ONLINE) == 0)
 893    {
 894       error = S2ERR_OUTOFSERVICE;
 895       wire_error = S2WERR_UNIT_OFFLINE;
 896    }
 897
 898    /* Queue request */
 899
 900    if(error == 0)
 901       PutRequest(unit->request_ports[ADOPT_QUEUE], (APTR)request, base);
 902    else
 903    {
 904       request->ios2_Req.io_Error = error;
 905       request->ios2_WireError = wire_error;
 906       complete = TRUE;
 907    }
 908
 909    /* Return */
 910
 911    return complete;
 912 }
 913
 914
 915
 916 /****** intelpro100.device/S2_ONLINE ***************************************
 917 *
 918 *   NAME
 919 *       S2_ONLINE
 920 *
 921 *   FUNCTION
 922 *       See SANA-II documentation.
 923 *
 924 ****************************************************************************
 925 *
 926 */
 927
 928 static BOOL CmdOnline(struct IOSana2Req *request, struct DevBase *base)
 929 {
 930    struct DevUnit *unit;
 931    BYTE error = 0;
 932    ULONG wire_error;
 933    UWORD i;
 934
 935    /* Check request is valid */
 936
 937    unit = (APTR)request->ios2_Req.io_Unit;
 938    if((unit->flags & UNITF_CONFIGURED) == 0)
 939    {
 940       error = S2ERR_BAD_STATE;
 941       wire_error = S2WERR_NOT_CONFIGURED;
 942    }
 943    if((unit->flags & UNITF_HAVEADAPTER) == 0)
 944    {
 945       error = S2ERR_OUTOFSERVICE;
 946       wire_error = S2WERR_RCVREL_HDW_ERR;
 947    }
 948
 949    /* Clear global and special stats and put adapter back online */
 950
 951    if(error == 0 && (unit->flags & UNITF_ONLINE) == 0)
 952    {
 953       UpdateStats(unit, base);
 954       unit->stats.PacketsReceived = 0;
 955       unit->stats.PacketsSent = 0;
 956       unit->stats.BadData = 0;
 957       unit->stats.Overruns = 0;
 958       unit->stats.UnknownTypesReceived = 0;
 959       unit->stats.Reconfigurations = 0;
 960
 961       for(i = 0; i < SPECIAL_STAT_COUNT; i++)
 962          unit->special_stats[i] = 0;
 963
 964       GoOnline(unit, base);
 965    }
 966
 967    /* Return */
 968
 969    request->ios2_Req.io_Error = error;
 970    request->ios2_WireError = wire_error;
 971    return TRUE;
 972 }
 973
 974
 975
 976 /****** intelpro100.device/S2_OFFLINE **************************************
 977 *
 978 *   NAME
 979 *       S2_OFFLINE
 980 *
 981 *   FUNCTION
 982 *       See SANA-II documentation.
 983 *
 984 ****************************************************************************
 985 *
 986 */
 987
 988 static BOOL CmdOffline(struct IOSana2Req *request, struct DevBase *base)
 989 {
 990    struct DevUnit *unit;
 991
 992    /* Put adapter offline */
 993
 994    unit = (APTR)request->ios2_Req.io_Unit;
 995    if((unit->flags & UNITF_ONLINE) != 0)
 996       GoOffline(unit, base);
 997
 998    /* Return */
 999
1000    return TRUE;
1001 }
1002
1003
1004
1005 /****** intelpro100.device/NSCMD_DEVICEQUERY *******************************
1006 *
1007 *   NAME
1008 *       NSCMD_DEVICEQUERY -- Query device capabilities.
1009 *
1010 *   FUNCTION
1011 *       See New-style Device documentation.
1012 *
1013 ****************************************************************************
1014 *
1015 * Note that we have to pretend the request structure is an IOStdReq.
1016 *
1017 */
1018
1019 static BOOL CmdDeviceQuery(struct IOStdReq *request,
1020    struct DevBase *base)
1021 {
1022    struct NSDeviceQueryResult *info;
1023
1024    /* Set structure size twice */
1025
1026    info = request->io_Data;
1027    request->io_Actual = info->SizeAvailable =
1028       (ULONG)OFFSET(NSDeviceQueryResult, SupportedCommands) + sizeof(APTR);
1029
1030    /* Report device details */
1031
1032    info->DeviceType = NSDEVTYPE_SANA2;
1033    info->DeviceSubType = 0;
1034
1035    info->SupportedCommands = (APTR)supported_commands;
1036
1037    /* Return */
1038
1039    return TRUE;
1040 }
1041
1042
1043
1044 /****** intelpro100.device/S2_ADDMULTICASTADDRESS **************************
1045 *
1046 *   NAME
1047 *       S2_ADDMULTICASTADDRESS
1048 *
1049 *   FUNCTION
1050 *       See SANA-II documentation.
1051 *
1052 ****************************************************************************
1053 *
1054 */
1055
1056 /****** intelpro100.device/S2_ADDMULTICASTADDRESSES ************************
1057 *
1058 *   NAME
1059 *       S2_ADDMULTICASTADDRESSES
1060 *
1061 *   FUNCTION
1062 *       See SANA-II documentation.
1063 *
1064 ****************************************************************************
1065 *
1066 */
1067
1068 static BOOL CmdAddMulticastAddresses(struct IOSana2Req *request,
1069    struct DevBase *base)
1070 {
1071    struct DevUnit *unit;
1072    BYTE error = 0;
1073    ULONG wire_error;
1074    BOOL complete = FALSE;
1075    UBYTE *lower_bound, *upper_bound;
1076
1077    unit = (APTR)request->ios2_Req.io_Unit;
1078
1079    lower_bound = request->ios2_SrcAddr;
1080    if(request->ios2_Req.io_Command == S2_ADDMULTICASTADDRESS)
1081       upper_bound = lower_bound;
1082    else
1083       upper_bound = request->ios2_DstAddr;
1084
1085    if(!AddMulticastRange(unit, lower_bound, upper_bound, base))
1086    {
1087       error = S2ERR_NO_RESOURCES;
1088       wire_error = S2WERR_GENERIC_ERROR;
1089    }
1090
1091    /* Update hardware filter if unit is online */
1092
1093    if(error == 0 && (unit->flags & UNITF_ONLINE) != 0
1094       && (unit->flags & UNITF_PROM) == 0)
1095    {
1096       PutRequest(unit->request_ports[WRITE_QUEUE], (APTR)request, base);
1097    }
1098    else
1099    {
1100       request->ios2_Req.io_Error = error;
1101       request->ios2_WireError = wire_error;
1102       complete = TRUE;
1103    }
1104
1105    /* Return */
1106
1107    return complete;
1108 }
1109
1110
1111
1112 /****** intelpro100.device/S2_DELMULTICASTADDRESS **************************
1113 *
1114 *   NAME
1115 *       S2_DELMULTICASTADDRESS
1116 *
1117 *   FUNCTION
1118 *       See SANA-II documentation.
1119 *
1120 ****************************************************************************
1121 *
1122 */
1123
1124 /****** intelpro100.device/S2_DELMULTICASTADDRESSES ************************
1125 *
1126 *   NAME
1127 *       S2_DELMULTICASTADDRESSES
1128 *
1129 *   FUNCTION
1130 *       See SANA-II documentation.
1131 *
1132 ****************************************************************************
1133 *
1134 */
1135
1136 static BOOL CmdDelMulticastAddresses(struct IOSana2Req *request,
1137    struct DevBase *base)
1138 {
1139    struct DevUnit *unit;
1140    BYTE error = 0;
1141    ULONG wire_error;
1142    BOOL complete = FALSE;
1143    UBYTE *lower_bound, *upper_bound;
1144
1145    unit = (APTR)request->ios2_Req.io_Unit;
1146
1147    lower_bound = request->ios2_SrcAddr;
1148    if(request->ios2_Req.io_Command == S2_DELMULTICASTADDRESS)
1149       upper_bound = lower_bound;
1150    else
1151       upper_bound = request->ios2_DstAddr;
1152
1153    if(!RemMulticastRange(unit, lower_bound, upper_bound, base))
1154    {
1155       error = S2ERR_BAD_STATE;
1156       wire_error = S2WERR_BAD_MULTICAST;
1157    }
1158
1159    /* Update hardware filter if unit is online */
1160
1161    if(error == 0 && (unit->flags & UNITF_ONLINE) != 0
1162       && (unit->flags & UNITF_PROM) == 0)
1163    {
1164       PutRequest(unit->request_ports[WRITE_QUEUE], (APTR)request, base);
1165    }
1166    else
1167    {
1168       request->ios2_Req.io_Error = error;
1169       request->ios2_WireError = wire_error;
1170       complete = TRUE;
1171    }
1172
1173    /* Return */
1174
1175    return complete;
1176 }
1177
1178
1179
1180 /****i* intelpro100.device/PutRequest **************************************
1181 *
1182 *   NAME
1183 *       PutRequest
1184 *
1185 *   SYNOPSIS
1186 *       PutRequest(port, request)
1187 *
1188 *       VOID PutRequest(struct MsgPort *, struct IORequest *);
1189 *
1190 ****************************************************************************
1191 *
1192 */
1193
1194 VOID PutRequest(struct MsgPort *port, struct IORequest *request,
1195    struct DevBase *base)
1196 {
1197    request->io_Flags &= ~IOF_QUICK;
1198    PutMsg(port, (APTR)request);
1199
1200    return;
1201 }
1202
1203
1204