workbench/devs/networks/prism2/request.c

   1 /*
   2
   3 Copyright (C) 2001-2013 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    | S2EVENT_CONNECT | S2EVENT_DISCONNECT)
  41
  42
  43 static BOOL CmdInvalid(struct IOSana2Req *request, struct DevBase *base);
  44 static BOOL CmdRead(struct IOSana2Req *request, struct DevBase *base);
  45 static BOOL CmdWrite(struct IOSana2Req *request, struct DevBase *base);
  46 static BOOL CmdFlush(struct IORequest *request, struct DevBase *base);
  47 static BOOL CmdS2DeviceQuery(struct IOSana2Req *request,
  48    struct DevBase *base);
  49 static BOOL CmdGetStationAddress(struct IOSana2Req *request,
  50    struct DevBase *base);
  51 static BOOL CmdConfigInterface(struct IOSana2Req *request,
  52    struct DevBase *base);
  53 static BOOL CmdBroadcast(struct IOSana2Req *request,
  54    struct DevBase *base);
  55 static BOOL CmdTrackType(struct IOSana2Req *request,
  56    struct DevBase *base);
  57 static BOOL CmdUntrackType(struct IOSana2Req *request,
  58    struct DevBase *base);
  59 static BOOL CmdGetTypeStats(struct IOSana2Req *request,
  60    struct DevBase *base);
  61 static BOOL CmdGetSpecialStats(struct IOSana2Req *request,
  62    struct DevBase *base);
  63 static BOOL CmdGetGlobalStats(struct IOSana2Req *request,
  64    struct DevBase *base);
  65 static BOOL CmdOnEvent(struct IOSana2Req *request, struct DevBase *base);
  66 static BOOL CmdReadOrphan(struct IOSana2Req *request,
  67    struct DevBase *base);
  68 static BOOL CmdOnline(struct IOSana2Req *request, struct DevBase *base);
  69 static BOOL CmdOffline(struct IOSana2Req *request, struct DevBase *base);
  70 static BOOL CmdDeviceQuery(struct IOStdReq *request,
  71    struct DevBase *base);
  72 static BOOL CmdAddMulticastAddresses(struct IOSana2Req *request,
  73    struct DevBase *base);
  74 static BOOL CmdDelMulticastAddresses(struct IOSana2Req *request,
  75    struct DevBase *base);
  76 static BOOL CmdGetSignalQuality(struct IOSana2Req *request,
  77    struct DevBase *base);
  78 static BOOL CmdGetNetworks(struct IOSana2Req *request,
  79    struct DevBase *base);
  80 static BOOL CmdSetOptions(struct IOSana2Req *request, struct DevBase *base);
  81 static BOOL CmdSetKey(struct IOSana2Req *request, struct DevBase *base);
  82 static BOOL CmdGetNetworkInfo(struct IOSana2Req *request,
  83    struct DevBase *base);
  84 static BOOL CmdGetCryptTypes(struct IOSana2Req *request,
  85    struct DevBase *base);
  86
  87
  88 static const UWORD supported_commands[] =
  89 {
  90    CMD_READ,
  91    CMD_WRITE,
  92    CMD_FLUSH,
  93    S2_DEVICEQUERY,
  94    S2_GETSTATIONADDRESS,
  95    S2_CONFIGINTERFACE,
  96    S2_ADDMULTICASTADDRESS,
  97    S2_DELMULTICASTADDRESS,
  98    S2_MULTICAST,
  99    S2_BROADCAST,
 100    S2_TRACKTYPE,
 101    S2_UNTRACKTYPE,
 102    S2_GETTYPESTATS,
 103    S2_GETSPECIALSTATS,
 104    S2_GETGLOBALSTATS,
 105    S2_ONEVENT,
 106    S2_READORPHAN,
 107    S2_ONLINE,
 108    S2_OFFLINE,
 109    NSCMD_DEVICEQUERY,
 110    S2_ADDMULTICASTADDRESSES,
 111    S2_DELMULTICASTADDRESSES,
 112    S2_GETSIGNALQUALITY,
 113    S2_GETNETWORKS,
 114    S2_SETOPTIONS,
 115    S2_SETKEY,
 116    S2_GETNETWORKINFO,
 117    S2_GETCRYPTTYPES,
 118    0
 119 };
 120
 121
 122 static const struct Sana2DeviceQuery sana2_info =
 123 {
 124    0,
 125    0,
 126    0,
 127    0,
 128    ETH_ADDRESSSIZE * 8,
 129    ETH_MTU,
 130    0,
 131    S2WireType_Ethernet
 132 };
 133
 134
 135 const TEXT badmulticast_name[] = "Bad multicasts";
 136 const TEXT retries_name[] = "Retries";
 137 const TEXT fifo_underruns_name[] = "Underruns";
 138
 139
 140 const TEXT *const special_stat_names[] =
 141 {
 142    badmulticast_name,
 143    retries_name,
 144    fifo_underruns_name
 145 };
 146
 147
 148
 149 /****i* prism2.device/ServiceRequest ***************************************
 150 *
 151 *   NAME
 152 *       ServiceRequest -- Attempt to service a device request.
 153 *
 154 *   SYNOPSIS
 155 *       ServiceRequest(request)
 156 *
 157 *       VOID ServiceRequest(struct IORequest *);
 158 *
 159 *   FUNCTION
 160 *       Attempts to carry out a request. The relevant unit's semaphore must
 161 *       be obtained before calling this function. This function releases the
 162 *       semaphore before returning.
 163 *
 164 *   INPUTS
 165 *       request
 166 *
 167 *   RESULT
 168 *       None.
 169 *
 170 *   EXAMPLE
 171 *
 172 *   NOTES
 173 *
 174 *   BUGS
 175 *
 176 *   SEE ALSO
 177 *
 178 ****************************************************************************
 179 *
 180 */
 181
 182 VOID ServiceRequest(struct IOSana2Req *request, struct DevBase *base)
 183 {
 184    BOOL complete;
 185
 186    switch(request->ios2_Req.io_Command)
 187    {
 188    case CMD_READ:
 189       complete = CmdRead(request, base);
 190       break;
 191    case CMD_WRITE:
 192       complete = CmdWrite(request, base);
 193       break;
 194    case CMD_FLUSH:
 195       complete = CmdFlush((APTR)request, base);
 196       break;
 197    case S2_DEVICEQUERY:
 198       complete = CmdS2DeviceQuery(request, base);
 199       break;
 200    case S2_GETSTATIONADDRESS:
 201       complete = CmdGetStationAddress(request, base);
 202       break;
 203    case S2_CONFIGINTERFACE:
 204       complete = CmdConfigInterface(request, base);
 205       break;
 206    case S2_ADDMULTICASTADDRESS:
 207       complete = CmdAddMulticastAddresses(request, base);
 208       break;
 209    case S2_DELMULTICASTADDRESS:
 210       complete = CmdDelMulticastAddresses(request, base);
 211       break;
 212    case S2_MULTICAST:
 213       complete = CmdWrite(request, base);
 214       break;
 215    case S2_BROADCAST:
 216       complete = CmdBroadcast(request, base);
 217       break;
 218    case S2_TRACKTYPE:
 219       complete = CmdTrackType(request, base);
 220       break;
 221    case S2_UNTRACKTYPE:
 222       complete = CmdUntrackType(request, base);
 223       break;
 224    case S2_GETTYPESTATS:
 225       complete = CmdGetTypeStats(request, base);
 226       break;
 227    case S2_GETSPECIALSTATS:
 228       complete = CmdGetSpecialStats(request, base);
 229       break;
 230    case S2_GETGLOBALSTATS:
 231       complete = CmdGetGlobalStats(request, base);
 232       break;
 233    case S2_ONEVENT:
 234       complete = CmdOnEvent(request, base);
 235       break;
 236    case S2_READORPHAN:
 237       complete = CmdReadOrphan(request, base);
 238       break;
 239    case S2_ONLINE:
 240       complete = CmdOnline(request, base);
 241       break;
 242    case S2_OFFLINE:
 243       complete = CmdOffline(request, base);
 244       break;
 245    case NSCMD_DEVICEQUERY:
 246       complete = CmdDeviceQuery((APTR)request, base);
 247       break;
 248    case S2_ADDMULTICASTADDRESSES:
 249       complete = CmdAddMulticastAddresses(request, base);
 250       break;
 251    case S2_DELMULTICASTADDRESSES:
 252       complete = CmdDelMulticastAddresses(request, base);
 253       break;
 254    case S2_GETSIGNALQUALITY:
 255       complete = CmdGetSignalQuality(request, base);
 256       break;
 257    case S2_GETNETWORKS:
 258       complete = CmdGetNetworks(request, base);
 259       break;
 260    case S2_SETOPTIONS:
 261       complete = CmdSetOptions(request, base);
 262       break;
 263    case S2_SETKEY:
 264       complete = CmdSetKey(request, base);
 265       break;
 266    case S2_GETNETWORKINFO:
 267       complete = CmdGetNetworkInfo(request, base);
 268       break;
 269    case S2_GETCRYPTTYPES:
 270       complete = CmdGetCryptTypes(request, base);
 271       break;
 272    default:
 273       complete = CmdInvalid(request, base);
 274    }
 275
 276    if(complete && ((request->ios2_Req.io_Flags & IOF_QUICK) == 0))
 277       ReplyMsg((APTR)request);
 278
 279    ReleaseSemaphore(
 280       &((struct DevUnit *)request->ios2_Req.io_Unit)->access_lock);
 281    return;
 282 }
 283
 284
 285
 286 /****i* prism2.device/CMD_INVALID ******************************************
 287 *
 288 *   NAME
 289 *       CMD_INVALID -- Reject an invalid command.
 290 *
 291 *   FUNCTION
 292 *
 293 *   INPUTS
 294 *       None.
 295 *
 296 *   RESULTS
 297 *       io_Error - IOERR_NOCMD.
 298 *
 299 *   EXAMPLE
 300 *
 301 *   NOTES
 302 *
 303 *   BUGS
 304 *
 305 *   SEE ALSO
 306 *
 307 ****************************************************************************
 308 *
 309 */
 310
 311 static BOOL CmdInvalid(struct IOSana2Req *request, struct DevBase *base)
 312 {
 313    request->ios2_Req.io_Error = IOERR_NOCMD;
 314    request->ios2_WireError = S2WERR_GENERIC_ERROR;
 315
 316    return TRUE;
 317 }
 318
 319
 320
 321 /****** prism2.device/CMD_READ *********************************************
 322 *
 323 *   NAME
 324 *       CMD_READ -- Read data.
 325 *
 326 *   FUNCTION
 327 *
 328 *   INPUTS
 329 *       io_Flags
 330 *       ios2_PacketType
 331 *       ios2_Data
 332 *
 333 *   RESULTS
 334 *       io_Flags
 335 *       io_Error
 336 *       ios2_WireError
 337 *       ios2_SrcAddr
 338 *       ios2_DstAddr
 339 *       ios2_DataLength
 340 *       ios2_Data
 341 *
 342 *   EXAMPLE
 343 *
 344 *   NOTES
 345 *
 346 *   BUGS
 347 *
 348 *   SEE ALSO
 349 *
 350 ****************************************************************************
 351 *
 352 */
 353
 354 static BOOL CmdRead(struct IOSana2Req *request, struct DevBase *base)
 355 {
 356    struct DevUnit *unit;
 357    struct Opener *opener;
 358    BOOL complete = FALSE;
 359
 360    unit = (APTR)request->ios2_Req.io_Unit;
 361
 362    if((unit->flags & UNITF_ONLINE) != 0)
 363    {
 364       opener = request->ios2_BufferManagement;
 365       PutRequest(&opener->read_port, (APTR)request, base);
 366    }
 367    else
 368    {
 369       request->ios2_Req.io_Error = S2ERR_OUTOFSERVICE;
 370       request->ios2_WireError = S2WERR_UNIT_OFFLINE;
 371       complete = TRUE;
 372    }
 373
 374    /* Return */
 375
 376    return complete;
 377 }
 378
 379
 380
 381 /****** prism2.device/CMD_WRITE ********************************************
 382 *
 383 *   NAME
 384 *       CMD_WRITE -- Write data.
 385 *
 386 *   FUNCTION
 387 *
 388 *   INPUTS
 389 *       io_Flags
 390 *       ios2_DstAddr
 391 *       ios2_PacketType
 392 *       ios2_DataLength
 393 *       ios2_Data
 394 *
 395 *   RESULTS
 396 *       io_Error
 397 *       ios2_WireError
 398 *
 399 *   EXAMPLE
 400 *
 401 *   NOTES
 402 *
 403 *   BUGS
 404 *
 405 *   SEE ALSO
 406 *
 407 ****************************************************************************
 408 *
 409 */
 410
 411 /****** prism2.device/S2_MULTICAST *****************************************
 412 *
 413 *   NAME
 414 *       S2_MULTICAST
 415 *
 416 *   FUNCTION
 417 *
 418 *   INPUTS
 419 *       io_Flags
 420 *       ios2_DstAddr - multicast address.
 421 *       ios2_PacketType
 422 *       ios2_DataLength
 423 *       ios2_Data
 424 *
 425 *   RESULTS
 426 *       io_Error
 427 *       ios2_WireError
 428 *
 429 *   EXAMPLE
 430 *
 431 *   NOTES
 432 *
 433 *   BUGS
 434 *
 435 *   SEE ALSO
 436 *
 437 ****************************************************************************
 438 *
 439 */
 440
 441 static BOOL CmdWrite(struct IOSana2Req *request, struct DevBase *base)
 442 {
 443    struct DevUnit *unit;
 444    BYTE error = 0;
 445    ULONG wire_error;
 446    BOOL complete = FALSE;
 447
 448    /* Check request is valid */
 449
 450    unit = (APTR)request->ios2_Req.io_Unit;
 451    if((unit->flags & UNITF_ONLINE) == 0)
 452    {
 453       error = S2ERR_OUTOFSERVICE;
 454       wire_error = S2WERR_UNIT_OFFLINE;
 455    }
 456    else if((request->ios2_Req.io_Command == S2_MULTICAST) &&
 457       ((request->ios2_DstAddr[0] & 0x1) == 0))
 458    {
 459       error = S2ERR_BAD_ADDRESS;
 460       wire_error = S2WERR_BAD_MULTICAST;
 461    }
 462
 463    /* Queue request for sending */
 464
 465    if(error == 0)
 466       PutRequest(unit->request_ports[WRITE_QUEUE], (APTR)request, base);
 467    else
 468    {
 469       request->ios2_Req.io_Error = error;
 470       request->ios2_WireError = wire_error;
 471       complete = TRUE;
 472    }
 473
 474    /* Return */
 475
 476    return complete;
 477 }
 478
 479
 480
 481 /****** prism2.device/CMD_FLUSH ********************************************
 482 *
 483 *   NAME
 484 *       CMD_FLUSH
 485 *
 486 *   FUNCTION
 487 *
 488 *   INPUTS
 489 *       None.
 490 *
 491 *   RESULTS
 492 *       io_Error
 493 *
 494 *   EXAMPLE
 495 *
 496 *   NOTES
 497 *
 498 *   BUGS
 499 *
 500 *   SEE ALSO
 501 *
 502 ****************************************************************************
 503 *
 504 */
 505
 506 static BOOL CmdFlush(struct IORequest *request, struct DevBase *base)
 507 {
 508    FlushUnit((APTR)request->io_Unit, EVENT_QUEUE, IOERR_ABORTED, base);
 509
 510    return TRUE;
 511 }
 512
 513
 514
 515 /****** prism2.device/S2_DEVICEQUERY ***************************************
 516 *
 517 *   NAME
 518 *       S2_DEVICEQUERY -- Query device capabilities.
 519 *
 520 *   FUNCTION
 521 *
 522 *   INPUTS
 523 *       ios2_StatData - Pointer to Sana2DeviceQuery structure.
 524 *
 525 *   RESULTS
 526 *       io_Error
 527 *       ios2_WireError
 528 *
 529 *   EXAMPLE
 530 *
 531 *   NOTES
 532 *
 533 *   BUGS
 534 *
 535 *   SEE ALSO
 536 *
 537 ****************************************************************************
 538 *
 539 */
 540
 541 static BOOL CmdS2DeviceQuery(struct IOSana2Req *request,
 542    struct DevBase *base)
 543 {
 544    struct DevUnit *unit;
 545    struct Sana2DeviceQuery *info;
 546    ULONG size_available, size;
 547
 548    /* Copy device info */
 549
 550    unit = (APTR)request->ios2_Req.io_Unit;
 551    info = request->ios2_StatData;
 552    size = size_available = info->SizeAvailable;
 553    if(size > sizeof(struct Sana2DeviceQuery))
 554       size = sizeof(struct Sana2DeviceQuery);
 555
 556    CopyMem(&sana2_info, info, size);
 557    info->BPS = unit->speed;
 558
 559    info->SizeAvailable = size_available;
 560    info->SizeSupplied = size;
 561
 562    /* Return */
 563
 564    return TRUE;
 565 }
 566
 567
 568
 569 /****** prism2.device/S2_GETSTATIONADDDRESS ********************************
 570 *
 571 *   NAME
 572 *       S2_GETSTATIONADDDRESS
 573 *
 574 *   FUNCTION
 575 *
 576 *   INPUTS
 577 *       None.
 578 *
 579 *   RESULTS
 580 *       io_Error
 581 *       ios2_WireError
 582 *       ios2_SrcAddr - current address.
 583 *       ios2_DstAddr - default address (zero if none?).
 584 *
 585 *   EXAMPLE
 586 *
 587 *   NOTES
 588 *
 589 *   BUGS
 590 *
 591 *   SEE ALSO
 592 *
 593 ****************************************************************************
 594 *
 595 */
 596
 597 static BOOL CmdGetStationAddress(struct IOSana2Req *request,
 598    struct DevBase *base)
 599 {
 600    struct DevUnit *unit;
 601
 602    /* Copy addresses */
 603
 604    unit = (APTR)request->ios2_Req.io_Unit;
 605    CopyMem(unit->address, request->ios2_SrcAddr, ETH_ADDRESSSIZE);
 606    CopyMem(unit->default_address, request->ios2_DstAddr, ETH_ADDRESSSIZE);
 607
 608    /* Return */
 609
 610    return TRUE;
 611 }
 612
 613
 614
 615 /****** prism2.device/S2_CONFIGINTERFACE ***********************************
 616 *
 617 *   NAME
 618 *       S2_CONFIGINTERFACE
 619 *
 620 *   FUNCTION
 621 *
 622 *   INPUTS
 623 *       ios2_SrcAddr - address to use.
 624 *
 625 *   RESULTS
 626 *       io_Error
 627 *       ios2_WireError
 628 *       ios2_SrcAddr - address used.
 629 *
 630 *   EXAMPLE
 631 *
 632 *   NOTES
 633 *
 634 *   BUGS
 635 *
 636 *   SEE ALSO
 637 *
 638 ****************************************************************************
 639 *
 640 */
 641
 642 static BOOL CmdConfigInterface(struct IOSana2Req *request,
 643    struct DevBase *base)
 644 {
 645    struct DevUnit *unit;
 646    BYTE error = 0;
 647    ULONG wire_error = S2WERR_GENERIC_ERROR;
 648
 649    /* Configure adapter */
 650
 651    unit = (APTR)request->ios2_Req.io_Unit;
 652    if((unit->flags & UNITF_CONFIGURED) != 0)
 653    {
 654       error = S2ERR_BAD_STATE;
 655       wire_error = S2WERR_IS_CONFIGURED;
 656    }
 657    else if((unit->flags & UNITF_HAVEADAPTER) == 0)
 658    {
 659       error = S2ERR_BAD_STATE;
 660    }
 661
 662    if(error == 0)
 663    {
 664       CopyMem(request->ios2_SrcAddr, unit->address, ETH_ADDRESSSIZE);
 665       ConfigureAdapter(unit, base);
 666       GoOnline(unit, base);
 667       unit->flags |= UNITF_CONFIGURED;
 668    }
 669    else
 670    {
 671       request->ios2_Req.io_Error = error;
 672       request->ios2_WireError = wire_error;
 673    }
 674
 675    /* Return */
 676
 677    return TRUE;
 678 }
 679
 680
 681
 682 /****** prism2.device/S2_BROADCAST *****************************************
 683 *
 684 *   NAME
 685 *       S2_BROADCAST
 686 *
 687 *   FUNCTION
 688 *
 689 *   INPUTS
 690 *       io_Flags
 691 *       ios2_PacketType
 692 *       ios2_DataLength
 693 *       ios2_Data
 694 *
 695 *   RESULTS
 696 *       io_Error
 697 *       ios2_WireError
 698 *
 699 *   EXAMPLE
 700 *
 701 *   NOTES
 702 *
 703 *   BUGS
 704 *
 705 *   SEE ALSO
 706 *
 707 ****************************************************************************
 708 *
 709 */
 710
 711 static BOOL CmdBroadcast(struct IOSana2Req *request,
 712    struct DevBase *base)
 713 {
 714    UWORD i;
 715
 716    /* Fill in the broadcast address as destination */
 717
 718    for(i = 0; i < ETH_ADDRESSSIZE; i++)
 719       request->ios2_DstAddr[i] = 0xff;
 720
 721    /* Queue the write as normal */
 722
 723    return CmdWrite(request, base);
 724 }
 725
 726
 727
 728 /****** prism2.device/S2_TRACKTYPE *****************************************
 729 *
 730 *   NAME
 731 *       S2_TRACKTYPE
 732 *
 733 *   FUNCTION
 734 *
 735 *   INPUTS
 736 *       ios2_PacketType - packet type to start tracking.
 737 *
 738 *   RESULTS
 739 *       io_Error
 740 *       ios2_WireError
 741 *
 742 *   EXAMPLE
 743 *
 744 *   NOTES
 745 *
 746 *   BUGS
 747 *
 748 *   SEE ALSO
 749 *
 750 ****************************************************************************
 751 *
 752 */
 753
 754 static BOOL CmdTrackType(struct IOSana2Req *request,
 755    struct DevBase *base)
 756 {
 757    struct DevUnit *unit;
 758    struct Opener *opener;
 759    ULONG packet_type, wire_error;
 760    struct TypeTracker *tracker;
 761    struct TypeStats *initial_stats;
 762    BYTE error = 0;
 763
 764    unit = (APTR)request->ios2_Req.io_Unit;
 765    packet_type = request->ios2_PacketType;
 766    if(packet_type <= ETH_MTU)
 767       packet_type = ETH_MTU;
 768
 769    /* Get global tracker */
 770
 771    tracker = (struct TypeTracker *)
 772       FindTypeStats(unit, &unit->type_trackers, packet_type, base);
 773
 774    if(tracker != NULL)
 775       tracker->user_count++;
 776    else
 777    {
 778       tracker =
 779          AllocMem(sizeof(struct TypeTracker), MEMF_PUBLIC | MEMF_CLEAR);
 780       if(tracker != NULL)
 781       {
 782          tracker->packet_type = packet_type;
 783          tracker->user_count = 1;
 784
 785          Disable();
 786          AddTail((APTR)&unit->type_trackers, (APTR)tracker);
 787          Enable();
 788       }
 789    }
 790
 791    /* Store initial figures for this opener */
 792
 793    opener = request->ios2_BufferManagement;
 794    initial_stats = FindTypeStats(unit, &opener->initial_stats, packet_type,
 795       base);
 796
 797    if(initial_stats != NULL)
 798    {
 799       error = S2ERR_BAD_STATE;
 800       wire_error = S2WERR_ALREADY_TRACKED;
 801    }
 802
 803    if(error == 0)
 804    {
 805       initial_stats = AllocMem(sizeof(struct TypeStats), MEMF_PUBLIC);
 806       if(initial_stats == NULL)
 807       {
 808          error = S2ERR_NO_RESOURCES;
 809          wire_error = S2WERR_GENERIC_ERROR;
 810       }
 811    }
 812
 813    if(error == 0)
 814    {
 815       CopyMem(tracker, initial_stats, sizeof(struct TypeStats));
 816       AddTail((APTR)&opener->initial_stats, (APTR)initial_stats);
 817    }
 818
 819    /* Return */
 820
 821    request->ios2_Req.io_Error = error;
 822    request->ios2_WireError = wire_error;
 823    return TRUE;
 824 }
 825
 826
 827
 828 /****** prism2.device/S2_UNTRACKTYPE ***************************************
 829 *
 830 *   NAME
 831 *       S2_UNTRACKTYPE
 832 *
 833 *   FUNCTION
 834 *
 835 *   INPUTS
 836 *       ios2_PacketType - packet type to stop tracking.
 837 *
 838 *   RESULTS
 839 *       io_Error
 840 *       ios2_WireError
 841 *
 842 *   EXAMPLE
 843 *
 844 *   NOTES
 845 *
 846 *   BUGS
 847 *
 848 *   SEE ALSO
 849 *
 850 ****************************************************************************
 851 *
 852 */
 853
 854 static BOOL CmdUntrackType(struct IOSana2Req *request,
 855    struct DevBase *base)
 856 {
 857    struct DevUnit *unit;
 858    struct Opener *opener;
 859    ULONG packet_type;
 860    struct TypeTracker *tracker;
 861    struct TypeStats *initial_stats;
 862
 863    unit = (APTR)request->ios2_Req.io_Unit;
 864    packet_type = request->ios2_PacketType;
 865    if(packet_type <= ETH_MTU)
 866       packet_type = ETH_MTU;
 867
 868    /* Get global tracker and initial figures */
 869
 870    tracker = (struct TypeTracker *)
 871       FindTypeStats(unit, &unit->type_trackers, packet_type, base);
 872    opener = request->ios2_BufferManagement;
 873    initial_stats = FindTypeStats(unit, &opener->initial_stats, packet_type,
 874       base);
 875
 876    /* Decrement tracker usage and free unused structures */
 877
 878    if(initial_stats != NULL)
 879    {
 880       if((--tracker->user_count) == 0)
 881       {
 882          Disable();
 883          Remove((APTR)tracker);
 884          Enable();
 885          FreeMem(tracker, sizeof(struct TypeTracker));
 886       }
 887
 888       Remove((APTR)initial_stats);
 889       FreeMem(initial_stats, sizeof(struct TypeStats));
 890    }
 891    else
 892    {
 893       request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 894       request->ios2_WireError = S2WERR_NOT_TRACKED;
 895    }
 896
 897    /* Return */
 898
 899    return TRUE;
 900 }
 901
 902
 903
 904 /****** prism2.device/S2_GETTYPESTATS **************************************
 905 *
 906 *   NAME
 907 *       S2_GETTYPESTATS
 908 *
 909 *   FUNCTION
 910 *
 911 *   INPUTS
 912 *       ios2_PacketType - packet type to get statistics on.
 913 *       ios2_StatData - pointer to a Sana2PacketTypeStats structure.
 914 *
 915 *   RESULTS
 916 *       io_Error
 917 *       ios2_WireError
 918 *
 919 *   EXAMPLE
 920 *
 921 *   NOTES
 922 *
 923 *   BUGS
 924 *
 925 *   SEE ALSO
 926 *
 927 ****************************************************************************
 928 *
 929 */
 930
 931 static BOOL CmdGetTypeStats(struct IOSana2Req *request,
 932    struct DevBase *base)
 933 {
 934    struct DevUnit *unit;
 935    struct Opener *opener;
 936    ULONG packet_type;
 937    struct TypeStats *initial_stats, *tracker;
 938    struct Sana2PacketTypeStats *stats;
 939
 940    unit = (APTR)request->ios2_Req.io_Unit;
 941    packet_type = request->ios2_PacketType;
 942
 943    /* Get global tracker and initial figures */
 944
 945    tracker = FindTypeStats(unit, &unit->type_trackers, packet_type, base);
 946    opener = request->ios2_BufferManagement;
 947    initial_stats = FindTypeStats(unit, &opener->initial_stats, packet_type,
 948       base);
 949
 950    /* Copy and adjust figures */
 951
 952    if(initial_stats != NULL)
 953    {
 954       stats = request->ios2_StatData;
 955       CopyMem(&tracker->stats, stats, sizeof(struct Sana2PacketTypeStats));
 956       stats->PacketsSent -= initial_stats->stats.PacketsSent;
 957       stats->PacketsReceived -= initial_stats->stats.PacketsReceived;
 958       stats->BytesSent -= initial_stats->stats.BytesSent;
 959       stats->BytesReceived -= initial_stats->stats.BytesReceived;
 960       stats->PacketsDropped -= initial_stats->stats.PacketsDropped;
 961    }
 962    else
 963    {
 964       request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 965       request->ios2_WireError = S2WERR_NOT_TRACKED;
 966    }
 967
 968    /* Return */
 969
 970    return TRUE;
 971 }
 972
 973
 974
 975 /****** prism2.device/S2_GETSPECIALSTATS ***********************************
 976 *
 977 *   NAME
 978 *       S2_GETSPECIALSTATS
 979 *
 980 *   FUNCTION
 981 *
 982 *   INPUTS
 983 *       ios2_StatData - Pointer to Sana2SpecialStatHeader structure.
 984 *
 985 *   RESULTS
 986 *       io_Error
 987 *       ios2_WireError
 988 *
 989 *   EXAMPLE
 990 *
 991 *   NOTES
 992 *
 993 *   BUGS
 994 *
 995 *   SEE ALSO
 996 *
 997 ****************************************************************************
 998 *
 999 */
1000
1001 static BOOL CmdGetSpecialStats(struct IOSana2Req *request,
1002    struct DevBase *base)
1003 {
1004    struct DevUnit *unit;
1005    UWORD i, stat_count;
1006    struct Sana2SpecialStatHeader *header;
1007    struct Sana2SpecialStatRecord *record;
1008
1009    /* Fill in stats */
1010
1011    unit = (APTR)request->ios2_Req.io_Unit;
1012    header = request->ios2_StatData;
1013    record = (APTR)(header + 1);
1014
1015    stat_count = header->RecordCountMax;
1016    if(stat_count > STAT_COUNT)
1017       stat_count = STAT_COUNT;
1018
1019    for(i = 0; i < stat_count; i++)
1020    {
1021       record->Type = (S2WireType_Ethernet << 16) + i;
1022       record->Count = unit->special_stats[i];
1023       record->String = special_stat_names[i];
1024       record++;
1025    }
1026
1027    header->RecordCountSupplied = stat_count;
1028
1029    /* Return */
1030
1031    return TRUE;
1032 }
1033
1034
1035
1036 /****** prism2.device/S2_GETGLOBALSTATS ************************************
1037 *
1038 *   NAME
1039 *       S2_GETGLOBALSTATS
1040 *
1041 *   FUNCTION
1042 *
1043 *   INPUTS
1044 *       ios2_StatData - Pointer to Sana2DeviceStats structure.
1045 *
1046 *   RESULTS
1047 *       io_Error
1048 *       ios2_WireError
1049 *
1050 *   EXAMPLE
1051 *
1052 *   NOTES
1053 *
1054 *   BUGS
1055 *
1056 *   SEE ALSO
1057 *
1058 ****************************************************************************
1059 *
1060 */
1061
1062 static BOOL CmdGetGlobalStats(struct IOSana2Req *request,
1063    struct DevBase *base)
1064 {
1065    struct DevUnit *unit;
1066
1067    /* Update and copy stats */
1068
1069    unit = (APTR)request->ios2_Req.io_Unit;
1070    if((unit->flags & UNITF_ONLINE) != 0)
1071       UpdateStats(unit, base);
1072    CopyMem(&unit->stats, request->ios2_StatData,
1073       sizeof(struct Sana2DeviceStats));
1074
1075    /* Return */
1076
1077    return TRUE;
1078 }
1079
1080
1081
1082 /****** prism2.device/S2_ONEVENT *******************************************
1083 *
1084 *   NAME
1085 *       S2_ONEVENT
1086 *
1087 *   FUNCTION
1088 *
1089 *   INPUTS
1090 *       ios2_WireError
1091 *
1092 *   RESULTS
1093 *       io_Error
1094 *       ios2_WireError
1095 *
1096 *   EXAMPLE
1097 *
1098 *   NOTES
1099 *
1100 *   BUGS
1101 *
1102 *   SEE ALSO
1103 *
1104 ****************************************************************************
1105 *
1106 */
1107
1108 static BOOL CmdOnEvent(struct IOSana2Req *request, struct DevBase *base)
1109 {
1110    struct DevUnit *unit;
1111    ULONG events, wanted_events;
1112    BOOL complete = FALSE;
1113
1114    /* Check if we understand the event types */
1115
1116    unit = (APTR)request->ios2_Req.io_Unit;
1117    wanted_events = request->ios2_WireError;
1118    if((wanted_events & ~KNOWN_EVENTS) != 0)
1119    {
1120       request->ios2_Req.io_Error = S2ERR_NOT_SUPPORTED;
1121       events = S2WERR_BAD_EVENT;
1122    }
1123    else
1124    {
1125       if((unit->flags & UNITF_ONLINE) != 0)
1126          events = S2EVENT_ONLINE;
1127       else
1128          events = S2EVENT_OFFLINE;
1129
1130       events &= wanted_events;
1131    }
1132
1133    /* Reply request if a wanted event has already occurred */
1134
1135    if(events != 0)
1136    {
1137       request->ios2_WireError = events;
1138       complete = TRUE;
1139    }
1140    else
1141       PutRequest(unit->request_ports[EVENT_QUEUE], (APTR)request, base);
1142
1143    /* Return */
1144
1145    return complete;
1146 }
1147
1148
1149
1150 /****** prism2.device/S2_READORPHAN ****************************************
1151 *
1152 *   NAME
1153 *       S2_READORPHAN
1154 *
1155 *   FUNCTION
1156 *
1157 *   INPUTS
1158 *       io_Flags
1159 *       ios2_Data
1160 *
1161 *   RESULTS
1162 *       io_Flags
1163 *       io_Error
1164 *       ios2_WireError
1165 *       ios2_PacketType - A copy of the packet's type field.
1166 *       ios2_SrcAddr
1167 *       ios2_DstAddr
1168 *       ios2_DataLength
1169 *       ios2_Data
1170 *
1171 *
1172 *   EXAMPLE
1173 *
1174 *   NOTES
1175 *
1176 *   BUGS
1177 *
1178 *   SEE ALSO
1179 *
1180 ****************************************************************************
1181 *
1182 */
1183
1184 static BOOL CmdReadOrphan(struct IOSana2Req *request,
1185    struct DevBase *base)
1186 {
1187    struct DevUnit *unit;
1188    BYTE error = 0;
1189    ULONG wire_error;
1190    BOOL complete = FALSE;
1191
1192    /* Check request is valid */
1193
1194    unit = (APTR)request->ios2_Req.io_Unit;
1195    if((unit->flags & UNITF_ONLINE) == 0)
1196    {
1197       error = S2ERR_OUTOFSERVICE;
1198       wire_error = S2WERR_UNIT_OFFLINE;
1199    }
1200
1201    /* Queue request */
1202
1203    if(error == 0)
1204       PutRequest(unit->request_ports[ADOPT_QUEUE], (APTR)request, base);
1205    else
1206    {
1207       request->ios2_Req.io_Error = error;
1208       request->ios2_WireError = wire_error;
1209       complete = TRUE;
1210    }
1211
1212    /* Return */
1213
1214    return complete;
1215 }
1216
1217
1218
1219 /****** prism2.device/S2_ONLINE ********************************************
1220 *
1221 *   NAME
1222 *       S2_ONLINE
1223 *
1224 *   FUNCTION
1225 *
1226 *   INPUTS
1227 *       None.
1228 *
1229 *   RESULTS
1230 *       io_Error
1231 *       ios2_WireError
1232 *
1233 *   EXAMPLE
1234 *
1235 *   NOTES
1236 *
1237 *   BUGS
1238 *
1239 *   SEE ALSO
1240 *
1241 ****************************************************************************
1242 *
1243 */
1244
1245 static BOOL CmdOnline(struct IOSana2Req *request, struct DevBase *base)
1246 {
1247    struct DevUnit *unit;
1248    BYTE error = 0;
1249    ULONG wire_error;
1250    UWORD i;
1251
1252    /* Check request is valid */
1253
1254    unit = (APTR)request->ios2_Req.io_Unit;
1255    if((unit->flags & UNITF_CONFIGURED) == 0)
1256    {
1257       error = S2ERR_BAD_STATE;
1258       wire_error = S2WERR_NOT_CONFIGURED;
1259    }
1260    if((unit->flags & UNITF_HAVEADAPTER) == 0)
1261    {
1262       error = S2ERR_OUTOFSERVICE;
1263       wire_error = S2WERR_RCVREL_HDW_ERR;
1264    }
1265
1266    /* Clear global and special stats and put adapter back online */
1267
1268    if(error == 0 && (unit->flags & UNITF_ONLINE) == 0)
1269    {
1270       unit->stats.PacketsReceived = 0;
1271       unit->stats.PacketsSent = 0;
1272       unit->stats.BadData = 0;
1273       unit->stats.Overruns = 0;
1274       unit->stats.UnknownTypesReceived = 0;
1275       unit->stats.Reconfigurations = 0;
1276
1277       for(i = 0; i < STAT_COUNT; i++)
1278          unit->special_stats[i] = 0;
1279
1280       GoOnline(unit, base);
1281    }
1282
1283    /* Return */
1284
1285    request->ios2_Req.io_Error = error;
1286    request->ios2_WireError = wire_error;
1287    return TRUE;
1288 }
1289
1290
1291
1292 /****** prism2.device/S2_OFFLINE *******************************************
1293 *
1294 *   NAME
1295 *       S2_OFFLINE
1296 *
1297 *   FUNCTION
1298 *
1299 *   INPUTS
1300 *       None.
1301 *
1302 *   RESULTS
1303 *       io_Error
1304 *       ios2_WireError
1305 *
1306 *   EXAMPLE
1307 *
1308 *   NOTES
1309 *
1310 *   BUGS
1311 *
1312 *   SEE ALSO
1313 *
1314 ****************************************************************************
1315 *
1316 */
1317
1318 static BOOL CmdOffline(struct IOSana2Req *request, struct DevBase *base)
1319 {
1320    struct DevUnit *unit;
1321
1322    /* Put adapter offline */
1323
1324    unit = (APTR)request->ios2_Req.io_Unit;
1325    if((unit->flags & UNITF_ONLINE) != 0)
1326       GoOffline(unit, base);
1327
1328    /* Return */
1329
1330    return TRUE;
1331 }
1332
1333
1334
1335 /****** prism2.device/NSCMD_DEVICEQUERY ************************************
1336 *
1337 *   NAME
1338 *       NSCMD_DEVICEQUERY -- Query device capabilities.
1339 *
1340 *   FUNCTION
1341 *
1342 *   INPUTS
1343 *       io_Length - ???.
1344 *       io_Data - pointer to NSDeviceQueryResult structure.
1345 *
1346 *   RESULTS
1347 *       io_Error
1348 *       io_Actual - size of structure device can handle.
1349 *
1350 *   EXAMPLE
1351 *
1352 *   NOTES
1353 *
1354 *   BUGS
1355 *
1356 *   SEE ALSO
1357 *
1358 ****************************************************************************
1359 *
1360 * Note that we have to pretend the request structure is an IOStdReq.
1361 *
1362 */
1363
1364 static BOOL CmdDeviceQuery(struct IOStdReq *request,
1365    struct DevBase *base)
1366 {
1367    struct NSDeviceQueryResult *info;
1368
1369    /* Set structure size twice */
1370
1371    info = request->io_Data;
1372    request->io_Actual = info->SizeAvailable =
1373       (ULONG)OFFSET(NSDeviceQueryResult, SupportedCommands) + sizeof(APTR);
1374
1375    /* Report device details */
1376
1377    info->DeviceType = NSDEVTYPE_SANA2;
1378    info->DeviceSubType = 0;
1379
1380    info->SupportedCommands = (APTR)supported_commands;
1381
1382    /* Return */
1383
1384    return TRUE;
1385 }
1386
1387
1388
1389 /****** prism2.device/S2_ADDMULTICASTADDRESS *******************************
1390 *
1391 *   NAME
1392 *       S2_ADDMULTICASTADDRESS
1393 *
1394 *   FUNCTION
1395 *
1396 *   INPUTS
1397 *       ios2_SrcAddr - multicast address.
1398 *
1399 *   RESULTS
1400 *       io_Error
1401 *       ios2_WireError
1402 *
1403 *   EXAMPLE
1404 *
1405 *   NOTES
1406 *
1407 *   BUGS
1408 *
1409 *   SEE ALSO
1410 *
1411 ****************************************************************************
1412 *
1413 */
1414
1415 /****** prism2.device/S2_ADDMULTICASTADDRESSES *****************************
1416 *
1417 *   NAME
1418 *       S2_ADDMULTICASTADDRESSES
1419 *
1420 *   FUNCTION
1421 *
1422 *   INPUTS
1423 *       ios2_SrcAddr - lower bound.
1424 *       ios2_DstAddr - upper bound.
1425 *
1426 *   RESULTS
1427 *       io_Error
1428 *       ios2_WireError
1429 *
1430 *   EXAMPLE
1431 *
1432 *   NOTES
1433 *
1434 *   BUGS
1435 *
1436 *   SEE ALSO
1437 *
1438 ****************************************************************************
1439 *
1440 */
1441
1442 static BOOL CmdAddMulticastAddresses(struct IOSana2Req *request,
1443    struct DevBase *base)
1444 {
1445    struct DevUnit *unit;
1446    UBYTE *lower_bound, *upper_bound;
1447
1448    unit = (APTR)request->ios2_Req.io_Unit;
1449
1450    lower_bound = request->ios2_SrcAddr;
1451    if(request->ios2_Req.io_Command == S2_ADDMULTICASTADDRESS)
1452       upper_bound = lower_bound;
1453    else
1454       upper_bound = request->ios2_DstAddr;
1455
1456    if(!AddMulticastRange(unit, lower_bound, upper_bound, base))
1457    {
1458       request->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
1459       request->ios2_WireError = S2WERR_GENERIC_ERROR;
1460    }
1461
1462    /* Return */
1463
1464    return TRUE;
1465 }
1466
1467
1468
1469 /****** prism2.device/S2_DELMULTICASTADDRESS *******************************
1470 *
1471 *   NAME
1472 *       S2_DELMULTICASTADDRESS
1473 *
1474 *   FUNCTION
1475 *
1476 *   INPUTS
1477 *       ios2_SrcAddr - multicast address.
1478 *
1479 *   RESULTS
1480 *       io_Error
1481 *       ios2_WireError
1482 *
1483 *   EXAMPLE
1484 *
1485 *   NOTES
1486 *
1487 *   BUGS
1488 *
1489 *   SEE ALSO
1490 *
1491 ****************************************************************************
1492 *
1493 */
1494
1495 /****** prism2.device/S2_DELMULTICASTADDRESSES *****************************
1496 *
1497 *   NAME
1498 *       S2_DELMULTICASTADDRESSES
1499 *
1500 *   FUNCTION
1501 *
1502 *   INPUTS
1503 *       ios2_SrcAddr - lower bound.
1504 *       ios2_DstAddr - upper bound.
1505 *
1506 *   RESULTS
1507 *       io_Error
1508 *       ios2_WireError
1509 *
1510 *   EXAMPLE
1511 *
1512 *   NOTES
1513 *
1514 *   BUGS
1515 *
1516 *   SEE ALSO
1517 *
1518 ****************************************************************************
1519 *
1520 */
1521
1522 static BOOL CmdDelMulticastAddresses(struct IOSana2Req *request,
1523    struct DevBase *base)
1524 {
1525    struct DevUnit *unit;
1526    UBYTE *lower_bound, *upper_bound;
1527
1528    unit = (APTR)request->ios2_Req.io_Unit;
1529
1530    lower_bound = request->ios2_SrcAddr;
1531    if(request->ios2_Req.io_Command == S2_DELMULTICASTADDRESS)
1532       upper_bound = lower_bound;
1533    else
1534       upper_bound = request->ios2_DstAddr;
1535
1536    if(!RemMulticastRange(unit, lower_bound, upper_bound, base))
1537    {
1538       request->ios2_Req.io_Error = S2ERR_BAD_STATE;
1539       request->ios2_WireError = S2WERR_BAD_MULTICAST;
1540    }
1541
1542    /* Return */
1543
1544    return TRUE;
1545 }
1546
1547
1548
1549 /****** prism2.device/S2_GETSIGNALQUALITY **********************************
1550 *
1551 *   NAME
1552 *       S2_GETSIGNALQUALITY -- Get signal quality statistics.
1553 *
1554 *   FUNCTION
1555 *       This command fills in the supplied Sana2SignalQuality structure with
1556 *       current signal and noise levels. The unit for these figures is dBm.
1557 *       Typically, they are negative values.
1558 *
1559 *   INPUTS
1560 *       ios2_StatData - Pointer to Sana2SignalQuality structure.
1561 *
1562 *   RESULTS
1563 *       io_Error - Zero if successful; non-zero otherwise.
1564 *       ios2_WireError - More specific error code.
1565 *
1566 ****************************************************************************
1567 *
1568 */
1569
1570 static BOOL CmdGetSignalQuality(struct IOSana2Req *request,
1571    struct DevBase *base)
1572 {
1573    struct DevUnit *unit;
1574
1575    /* Update and copy stats */
1576
1577    unit = (APTR)request->ios2_Req.io_Unit;
1578    if((unit->flags & UNITF_ONLINE) != 0)
1579    {
1580       UpdateSignalQuality(unit, base);
1581       CopyMem(&unit->signal_quality, request->ios2_StatData,
1582          sizeof(struct Sana2SignalQuality));
1583    }
1584    else
1585    {
1586       request->ios2_Req.io_Error = S2ERR_OUTOFSERVICE;
1587       request->ios2_WireError = S2WERR_UNIT_OFFLINE;
1588    }
1589
1590    /* Return */
1591
1592    return TRUE;
1593 }
1594
1595
1596
1597 /****** prism2.device/S2_GETNETWORKS ***************************************
1598 *
1599 *   NAME
1600 *       S2_GETNETWORKS -- Scan for available networks.
1601 *
1602 *   FUNCTION
1603 *       This command supplies details of available networks. If the scan
1604 *       should be limited to one specific network, the S2INFO_SSID tag
1605 *       should specify its name.
1606 *
1607 *       If this command completes successfully, ios2_StatData will contain
1608 *       an array of pointers to tag lists, each of which contains
1609 *       information on a single network. The device will set ios2_DataLength
1610 *       to the number of elements in this array.
1611 *
1612 *       The returned taglists are allocated from the supplied memory pool.
1613 *       To discard the results of this command, the entire memory pool
1614 *       should be destroyed.
1615 *
1616 *   INPUTS
1617 *       ios2_Data - Pointer to an Exec memory pool.
1618 *       ios2_StatData - Pointer to taglist that specifies parameters to use.
1619 *
1620 *   RESULTS
1621 *       io_Error - Zero if successful; non-zero otherwise.
1622 *       ios2_WireError - More specific error code.
1623 *       ios2_DataLength - Number of tag lists returned.
1624 *       ios2_Data - Remains unchanged.
1625 *       ios2_StatData - Pointer to an array of tag lists.
1626 *
1627 ****************************************************************************
1628 *
1629 */
1630
1631 static BOOL CmdGetNetworks(struct IOSana2Req *request,
1632    struct DevBase *base)
1633 {
1634    struct DevUnit *unit;
1635    BOOL complete = FALSE;
1636    const TEXT *ssid;
1637    const struct TagItem *tag_list;
1638
1639    /* Request a new scan and queue request to receive results */
1640
1641    unit = (APTR)request->ios2_Req.io_Unit;
1642    if((unit->flags & UNITF_ONLINE) != 0)
1643    {
1644       PutRequest(unit->request_ports[SCAN_QUEUE], (APTR)request, base);
1645       tag_list = (const struct TagItem *)request->ios2_StatData;
1646       ssid = (const TEXT *)GetTagData(S2INFO_SSID, (UPINT)NULL, tag_list);
1647       StartScan(unit, ssid, base);
1648    }
1649    else
1650    {
1651       request->ios2_Req.io_Error = S2ERR_OUTOFSERVICE;
1652       request->ios2_WireError = S2WERR_UNIT_OFFLINE;
1653       complete = TRUE;
1654    }
1655
1656    /* Return */
1657
1658    return complete;
1659 }
1660
1661
1662
1663 /****** prism2.device/S2_SETOPTIONS ****************************************
1664 *
1665 *   NAME
1666 *       S2_SETOPTIONS -- Set network options.
1667 *
1668 *   FUNCTION
1669 *       Set various parameters for the network interface. This command
1670 *       should be called before going online to set any essential parameters
1671 *       not covered elsewhere.
1672 *
1673 *   INPUTS
1674 *       ios2_Data - Pointer to taglist that specifies the parameters to use.
1675 *
1676 *   RESULTS
1677 *       io_Error - Zero if successful; non-zero otherwise.
1678 *       ios2_WireError - More specific error code.
1679 *
1680 ****************************************************************************
1681 *
1682 */
1683
1684 static BOOL CmdSetOptions(struct IOSana2Req *request, struct DevBase *base)
1685 {
1686    struct DevUnit *unit;
1687
1688    /* Set options, and reconfigure if already online */
1689
1690    unit = (APTR)request->ios2_Req.io_Unit;
1691    SetOptions(unit, request->ios2_Data, base);
1692    if((unit->flags & UNITF_ONLINE) != 0)
1693       ConfigureAdapter(unit, base);
1694    unit->stats.Reconfigurations++;
1695
1696    /* Return */
1697
1698    return TRUE;
1699 }
1700
1701
1702
1703 /****** prism2.device/S2_SETKEY ********************************************
1704 *
1705 *   NAME
1706 *       S2_SETKEY -- Set an encryption key.
1707 *
1708 *   FUNCTION
1709 *
1710 *   INPUTS
1711 *       ios2_WireError - Key index.
1712 *       ios2_PacketType - Encryption type (e.g. S2ENC_WEP).
1713 *       ios2_DataLength - Key length.
1714 *       ios2_Data - Key.
1715 *       ios2_StatData - RX counter number (NULL if unused).
1716 *
1717 *   RESULTS
1718 *       io_Error
1719 *
1720 *   EXAMPLE
1721 *
1722 *   NOTES
1723 *
1724 *   BUGS
1725 *
1726 *   SEE ALSO
1727 *
1728 ****************************************************************************
1729 *
1730 */
1731
1732 static BOOL CmdSetKey(struct IOSana2Req *request, struct DevBase *base)
1733 {
1734    struct DevUnit *unit;
1735
1736    unit = (APTR)request->ios2_Req.io_Unit;
1737    SetKey(unit, request->ios2_WireError, request->ios2_PacketType,
1738       request->ios2_Data, request->ios2_DataLength, request->ios2_StatData,
1739       base);
1740
1741    /* Return */
1742
1743    return TRUE;
1744 }
1745
1746
1747
1748 /****** prism2.device/S2_GETNETWORKINFO ************************************
1749 *
1750 *   NAME
1751 *       S2_GETNETWORKINFO -- Get information on current network.
1752 *
1753 *   FUNCTION
1754 *
1755 *   INPUTS
1756 *       ios2_Data - Pointer to an Exec memory pool.
1757 *
1758 *   RESULTS
1759 *       ios2_Data - Remains unchanged.
1760 *       ios2_StatData - Pointer to a tag list.
1761 *       io_Error - Zero if successful; non-zero otherwise.
1762 *       ios2_WireError - More specific error code.
1763 *
1764 ****************************************************************************
1765 *
1766 */
1767
1768 static BOOL CmdGetNetworkInfo(struct IOSana2Req *request,
1769    struct DevBase *base)
1770 {
1771    struct DevUnit *unit;
1772    APTR pool;
1773
1774    /* Request information on current network */
1775
1776    unit = (APTR)request->ios2_Req.io_Unit;
1777    pool = request->ios2_Data;
1778    if((unit->flags & UNITF_ONLINE) != 0)
1779    {
1780       request->ios2_StatData = GetNetworkInfo(unit, pool, base);
1781       if(request->ios2_StatData == NULL)
1782          request->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
1783    }
1784    else
1785    {
1786       request->ios2_Req.io_Error = S2ERR_OUTOFSERVICE;
1787       request->ios2_WireError = S2WERR_UNIT_OFFLINE;
1788    }
1789
1790    /* Return */
1791
1792    return TRUE;
1793 }
1794
1795
1796
1797 /****** prism2.device/S2_GETCRYPTTYPES *************************************
1798 *
1799 *   NAME
1800 *       S2_GETCRYPTTYPES -- Get encryption capabilities.
1801 *
1802 *   FUNCTION
1803 *       This command returns a list of encryption types supported by the
1804 *       device (including S2ENC_NONE).
1805 *
1806 *   INPUTS
1807 *       ios2_Data - Pointer to an Exec memory pool.
1808 *
1809 *   RESULTS
1810 *       ios2_Data - Remains unchanged.
1811 *       ios2_DataLength - Number of encryption types returned.
1812 *       ios2_StatData - Pointer to a UBYTE array of encryption types.
1813 *       io_Error - Zero if successful; non-zero otherwise.
1814 *       ios2_WireError - More specific error code.
1815 *
1816 ****************************************************************************
1817 *
1818 */
1819
1820 static BOOL CmdGetCryptTypes(struct IOSana2Req *request,
1821    struct DevBase *base)
1822 {
1823    struct DevUnit *unit;
1824    APTR pool;
1825    UBYTE *list;
1826
1827    /* Allocate array and fill it with supported encryption types */
1828
1829    unit = (APTR)request->ios2_Req.io_Unit;
1830    pool = request->ios2_Data;
1831    list = AllocPooled(pool, 4 * sizeof(UBYTE));
1832
1833    if(list != NULL)
1834    {
1835       request->ios2_StatData = list;
1836       *list++ = S2ENC_NONE;
1837       if((unit->flags & UNITF_HASWEP) != 0)
1838          *list++ = S2ENC_WEP;
1839       if((unit->flags & UNITF_HASTKIP) != 0)
1840          *list++ = S2ENC_TKIP;
1841       if((unit->flags & UNITF_HASCCMP) != 0)
1842          *list++ = S2ENC_CCMP;
1843       request->ios2_DataLength =
1844          (UPINT)list - (UPINT)request->ios2_StatData;
1845    }
1846    else
1847       request->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
1848
1849    /* Return */
1850
1851    return TRUE;
1852 }
1853
1854
1855
1856 /****i* prism2.device/PutRequest *******************************************
1857 *
1858 *   NAME
1859 *       PutRequest
1860 *
1861 *   SYNOPSIS
1862 *       PutRequest(port, request)
1863 *
1864 *       VOID PutRequest(struct MsgPort *, struct IORequest *);
1865 *
1866 *   FUNCTION
1867 *
1868 *   INPUTS
1869 *       port
1870 *       request
1871 *
1872 *   RESULT
1873 *       None.
1874 *
1875 ****************************************************************************
1876 *
1877 */
1878
1879 VOID PutRequest(struct MsgPort *port, struct IORequest *request,
1880    struct DevBase *base)
1881 {
1882    request->io_Flags &= ~IOF_QUICK;
1883    PutMsg(port, (APTR)request);
1884
1885    return;
1886 }
1887
1888
1889