workbench/devs/networks/prism2/request.c

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