workbench/devs/networks/sis900/handler.c

   1 /*
   2  * $Id$
   3  */
   4
   5 /*
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful, but
  12     WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14     General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  19     MA 02111-1307, USA.
  20 */
  21
  22 #include <string.h>
  23
  24 #include <exec/types.h>
  25 #include <exec/resident.h>
  26 #include <exec/io.h>
  27 #include <exec/ports.h>
  28 #include <exec/errors.h>
  29
  30 #include <devices/sana2.h>
  31 #include <devices/sana2specialstats.h>
  32 #include <devices/newstyle.h>
  33
  34 #include <utility/utility.h>
  35 #include <utility/tagitem.h>
  36 #include <utility/hooks.h>
  37
  38 #include <proto/exec.h>
  39 #include <proto/dos.h>
  40 #include <proto/battclock.h>
  41
  42 #include <stdlib.h>
  43
  44 #include "sis900.h"
  45 #include "unit.h"
  46 #include LC_LIBDEFS_FILE
  47
  48 #define KNOWN_EVENTS \
  49     (S2EVENT_ERROR | S2EVENT_TX | S2EVENT_RX | S2EVENT_ONLINE \
  50     | S2EVENT_OFFLINE | S2EVENT_BUFF | S2EVENT_HARDWARE | S2EVENT_SOFTWARE)
  51
  52 static BOOL CmdInvalid(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  53 static BOOL CmdRead(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  54 static BOOL CmdWrite(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  55 static BOOL CmdFlush(LIBBASETYPEPTR LIBBASE, struct IORequest *request);
  56 static BOOL CmdS2DeviceQuery(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  57 static BOOL CmdGetStationAddress(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  58 static BOOL CmdConfigInterface(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  59 static BOOL CmdBroadcast(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  60 static BOOL CmdTrackType(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  61 static BOOL CmdUntrackType(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  62 static BOOL CmdGetTypeStats(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  63 static BOOL CmdGetGlobalStats(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  64 static BOOL CmdDeviceQuery(LIBBASETYPEPTR LIBBASE, struct IOStdReq *request);
  65 static BOOL CmdOnEvent(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  66 static BOOL CmdReadOrphan(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  67 static BOOL CmdOnline(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  68 static BOOL CmdOffline(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  69 static BOOL CmdAddMulticastAddresses(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  70 static BOOL CmdDelMulticastAddresses(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request);
  71
  72 static const UWORD supported_commands[] =
  73 {
  74     CMD_READ,
  75     CMD_WRITE,
  76     CMD_FLUSH,
  77     S2_DEVICEQUERY,
  78     S2_GETSTATIONADDRESS,
  79     S2_CONFIGINTERFACE,
  80     S2_ADDMULTICASTADDRESS,
  81     S2_DELMULTICASTADDRESS,
  82     S2_MULTICAST,
  83     S2_BROADCAST,
  84     S2_TRACKTYPE,
  85     S2_UNTRACKTYPE,
  86     S2_GETTYPESTATS,
  87 //    S2_GETSPECIALSTATS,
  88     S2_GETGLOBALSTATS,
  89     S2_ONEVENT,
  90     S2_READORPHAN,
  91     S2_ONLINE,
  92     S2_OFFLINE,
  93     NSCMD_DEVICEQUERY,
  94     S2_ADDMULTICASTADDRESSES,
  95     S2_DELMULTICASTADDRESSES,
  96     0
  97 };
  98
  99 void handle_request(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 100 {
 101     BOOL complete;
 102
 103     switch(request->ios2_Req.io_Command)
 104     {
 105         case CMD_READ:
 106             complete = CmdRead(LIBBASE, request);
 107             break;
 108
 109         case CMD_WRITE:
 110         case S2_MULTICAST:
 111             complete = CmdWrite(LIBBASE, request);
 112             break;
 113
 114         case CMD_FLUSH:
 115             complete = CmdFlush(LIBBASE, (struct IORequest *)request);
 116             break;
 117
 118         case S2_DEVICEQUERY:
 119             complete = CmdS2DeviceQuery(LIBBASE, request);
 120             break;
 121
 122         case S2_GETSTATIONADDRESS:
 123             complete = CmdGetStationAddress(LIBBASE, request);
 124             break;
 125
 126         case S2_CONFIGINTERFACE:
 127             complete = CmdConfigInterface(LIBBASE, request);
 128             break;
 129
 130         case S2_BROADCAST:
 131             complete = CmdBroadcast(LIBBASE, request);
 132             break;
 133
 134         case S2_TRACKTYPE:
 135             complete = CmdTrackType(LIBBASE, request);
 136             break;
 137
 138         case S2_UNTRACKTYPE:
 139             complete = CmdUntrackType(LIBBASE, request);
 140             break;
 141
 142         case S2_GETTYPESTATS:
 143             complete = CmdGetTypeStats(LIBBASE, request);
 144             break;
 145
 146         case S2_GETGLOBALSTATS:
 147             complete = CmdGetGlobalStats(LIBBASE, request);
 148             break;
 149
 150         case S2_ONEVENT:
 151             complete = CmdOnEvent(LIBBASE, request);
 152             break;
 153
 154         case S2_READORPHAN:
 155             complete = CmdReadOrphan(LIBBASE, request);
 156             break;
 157
 158         case S2_ONLINE:
 159             complete = CmdOnline(LIBBASE, request);
 160             break;
 161
 162         case S2_OFFLINE:
 163             complete = CmdOffline(LIBBASE, request);
 164             break;
 165
 166         case S2_ADDMULTICASTADDRESS:
 167         case S2_ADDMULTICASTADDRESSES:
 168             complete = CmdAddMulticastAddresses(LIBBASE, request);
 169             break;
 170
 171         case S2_DELMULTICASTADDRESS:
 172         case S2_DELMULTICASTADDRESSES:
 173             complete = CmdDelMulticastAddresses(LIBBASE, request);
 174             break;
 175
 176         case NSCMD_DEVICEQUERY:
 177             complete = CmdDeviceQuery(LIBBASE, (struct IOStdReq *)request);
 178             break;
 179
 180         default:
 181             complete = CmdInvalid(LIBBASE, request);
 182     }
 183
 184     if(complete && (request->ios2_Req.io_Flags & IOF_QUICK) == 0)
 185         ReplyMsg((APTR)request);
 186
 187     ReleaseSemaphore(&((struct SiS900Unit *)request->ios2_Req.io_Unit)->sis900u_unit_lock);
 188 }
 189
 190 static BOOL CmdInvalid(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 191 {
 192     request->ios2_Req.io_Error = IOERR_NOCMD;
 193     request->ios2_WireError = S2WERR_GENERIC_ERROR;
 194
 195     return TRUE;
 196 }
 197
 198 static BOOL CmdRead(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 199 {
 200     struct SiS900Unit *unit;
 201     struct Opener *opener;
 202     BOOL complete = FALSE;
 203
 204     unit = (APTR)request->ios2_Req.io_Unit;
 205
 206 D(bug("[%s]: S2CmdRead()\n", unit->sis900u_name));
 207
 208     if((unit->sis900u_ifflags & IFF_UP) != 0)
 209     {
 210         opener = request->ios2_BufferManagement;
 211         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 212         PutMsg(&opener->read_port, (struct Message *)request);
 213     }
 214     else
 215     {
 216         request->ios2_Req.io_Error = S2ERR_OUTOFSERVICE;
 217         request->ios2_WireError = S2WERR_UNIT_OFFLINE;
 218         complete = TRUE;
 219     }
 220
 221     /* Return */
 222
 223     return complete;
 224 }
 225
 226 static BOOL CmdWrite(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 227 {
 228     struct SiS900Unit *unit;
 229     BYTE error = 0;
 230     ULONG wire_error = S2WERR_GENERIC_ERROR;
 231     BOOL complete = FALSE;
 232
 233     /* Check request is valid */
 234
 235     unit = (APTR)request->ios2_Req.io_Unit;
 236
 237 D(bug("[%s]: S2CmdWrite()\n", unit->sis900u_name));
 238
 239     if((unit->sis900u_ifflags & IFF_UP) == 0)
 240     {
 241         error = S2ERR_OUTOFSERVICE;
 242         wire_error = S2WERR_UNIT_OFFLINE;
 243     }
 244     else if((request->ios2_Req.io_Command == S2_MULTICAST) &&
 245             ((request->ios2_DstAddr[0] & 0x1) == 0))
 246     {
 247         error = S2ERR_BAD_ADDRESS;
 248         wire_error = S2WERR_BAD_MULTICAST;
 249     }
 250
 251     /* Queue request for sending */
 252
 253     if(error == 0) {
 254         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 255         PutMsg(unit->sis900u_request_ports[WRITE_QUEUE], (APTR)request);
 256     }
 257     else
 258     {
 259         request->ios2_Req.io_Error = error;
 260         request->ios2_WireError = wire_error;
 261         complete = TRUE;
 262     }
 263
 264     /* Return */
 265
 266     return complete;
 267 }
 268
 269 static BOOL CmdFlush(LIBBASETYPEPTR LIBBASE, struct IORequest *request)
 270 {
 271     FlushUnit(LIBBASE, (APTR)request->io_Unit, EVENT_QUEUE, IOERR_ABORTED);
 272     return TRUE;
 273 }
 274
 275 static BOOL CmdS2DeviceQuery(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 276 {
 277     struct SiS900Unit *unit = (APTR)request->ios2_Req.io_Unit;
 278 //    struct fe_priv *np = unit->sis900u_fe_priv;
 279     struct Sana2DeviceQuery *info;
 280     ULONG size_available, size, status;
 281     int i = 0;
 282
 283 D(bug("[%s]: S2CmdDeviceQuery()\n", unit->sis900u_name));
 284
 285     /* STSOUT register is Latched on Transition, read operation updates it */
 286     while (i++ < 2)
 287         status = mdio_read(unit, unit->cur_phy, MII_STSOUT);
 288
 289 D(bug("[%s]: S2CmdDeviceQuery: PHY status %x\n", unit->sis900u_name, status));
 290
 291     /* Copy device info */
 292     info = request->ios2_StatData;
 293     size = size_available = info->SizeAvailable;
 294     if(size > sizeof(struct Sana2DeviceQuery))
 295         size = sizeof(struct Sana2DeviceQuery);
 296
 297     CopyMem(&unit->sis900u_Sana2Info, info, size);
 298
 299     if (status & MII_STSOUT_SPD)
 300                 info->BPS = 100000000;
 301     else
 302                 info->BPS = 10000000;
 303
 304     info->MTU = unit->sis900u_mtu;
 305     info->HardwareType = S2WireType_Ethernet;
 306     info->SizeAvailable = size_available;
 307     info->SizeSupplied = size;
 308
 309     /* Return */
 310
 311     return TRUE;
 312 }
 313
 314 static BOOL CmdGetStationAddress(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 315 {
 316     struct SiS900Unit *unit;
 317
 318     /* Copy addresses */
 319
 320     unit = (APTR)request->ios2_Req.io_Unit;
 321
 322 D(bug("[%s]: S2CmdGetStationAddress()\n", unit->sis900u_name));
 323
 324     CopyMem(unit->sis900u_dev_addr, request->ios2_SrcAddr, ETH_ADDRESSSIZE);
 325     CopyMem(unit->sis900u_org_addr, request->ios2_DstAddr, ETH_ADDRESSSIZE);
 326
 327     /* Return */
 328
 329     return TRUE;
 330 }
 331
 332 static BOOL CmdConfigInterface(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 333 {
 334     struct SiS900Unit *unit;
 335
 336     /* Configure adapter */
 337
 338     unit = (APTR)request->ios2_Req.io_Unit;
 339
 340 D(bug("[%s]: S2CmdConfigInterface()\n", unit->sis900u_name));
 341
 342     if((unit->sis900u_ifflags & IFF_CONFIGURED) == 0)
 343     {
 344         CopyMem(request->ios2_SrcAddr, unit->sis900u_dev_addr, ETH_ADDRESSSIZE);
 345         sis900func_set_mac(unit);
 346         unit->sis900u_ifflags |= IFF_CONFIGURED;
 347     }
 348     else
 349     {
 350         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 351         request->ios2_WireError = S2WERR_IS_CONFIGURED;
 352     }
 353
 354     /* Return */
 355
 356     return TRUE;
 357 }
 358
 359 static BOOL CmdBroadcast(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 360 {
 361     /* Fill in the broadcast address as destination */
 362
 363     memset(request->ios2_DstAddr, 0xff, 6);
 364
 365     /* Queue the write as normal */
 366
 367     return CmdWrite(LIBBASE, request);
 368 }
 369
 370 static BOOL CmdTrackType(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 371 {
 372     struct SiS900Unit *unit;
 373     struct Opener *opener;
 374     ULONG packet_type, wire_error=0;
 375     struct TypeTracker *tracker;
 376     struct TypeStats *initial_stats;
 377     BYTE error = 0;
 378
 379     unit = (APTR)request->ios2_Req.io_Unit;
 380
 381 D(bug("[%s]: S2CmdTrackType()\n", unit->sis900u_name));
 382
 383     packet_type = request->ios2_PacketType;
 384
 385     /* Get global tracker */
 386
 387     tracker = (struct TypeTracker *)
 388         FindTypeStats(LIBBASE, unit, &unit->sis900u_type_trackers, packet_type);
 389
 390     if(tracker != NULL)
 391         tracker->user_count++;
 392     else
 393     {
 394         tracker =
 395             AllocMem(sizeof(struct TypeTracker), MEMF_PUBLIC|MEMF_CLEAR);
 396         if(tracker != NULL)
 397         {
 398             tracker->packet_type = packet_type;
 399             tracker->user_count = 1;
 400
 401             Disable();
 402             AddTail((APTR)&unit->sis900u_type_trackers, (APTR)tracker);
 403             Enable();
 404         }
 405    }
 406
 407     /* Store initial figures for this opener */
 408
 409     opener = request->ios2_BufferManagement;
 410     initial_stats = FindTypeStats(LIBBASE, unit, &opener->initial_stats, packet_type);
 411
 412     if(initial_stats != NULL)
 413     {
 414         error = S2ERR_BAD_STATE;
 415         wire_error = S2WERR_ALREADY_TRACKED;
 416     }
 417
 418     if(error == 0)
 419     {
 420         initial_stats = AllocMem(sizeof(struct TypeStats), MEMF_PUBLIC);
 421         if(initial_stats == NULL)
 422         {
 423             error = S2ERR_NO_RESOURCES;
 424             wire_error = S2WERR_GENERIC_ERROR;
 425         }
 426     }
 427
 428     if(error == 0)
 429     {
 430         CopyMem(tracker, initial_stats, sizeof(struct TypeStats));
 431         AddTail((APTR)&opener->initial_stats, (APTR)initial_stats);
 432     }
 433
 434     /* Return */
 435
 436     request->ios2_Req.io_Error = error;
 437     request->ios2_WireError = wire_error;
 438     return TRUE;
 439 }
 440
 441 static BOOL CmdUntrackType(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 442 {
 443     struct SiS900Unit *unit;
 444     struct Opener *opener;
 445     ULONG packet_type;
 446     struct TypeTracker *tracker;
 447     struct TypeStats *initial_stats;
 448
 449     unit = (APTR)request->ios2_Req.io_Unit;
 450
 451 D(bug("[%s]: S2CmdUntrackType()\n", unit->sis900u_name));
 452
 453     packet_type = request->ios2_PacketType;
 454
 455     /* Get global tracker and initial figures */
 456
 457     tracker = (struct TypeTracker *)
 458         FindTypeStats(LIBBASE, unit, &unit->sis900u_type_trackers, packet_type);
 459     opener = request->ios2_BufferManagement;
 460     initial_stats = FindTypeStats(LIBBASE, unit, &opener->initial_stats, packet_type);
 461
 462     /* Decrement tracker usage and free unused structures */
 463
 464     if(initial_stats != NULL)
 465     {
 466         if((--tracker->user_count) == 0)
 467         {
 468             Disable();
 469             Remove((APTR)tracker);
 470             Enable();
 471             FreeMem(tracker, sizeof(struct TypeTracker));
 472         }
 473
 474         Remove((APTR)initial_stats);
 475         FreeMem(initial_stats, sizeof(struct TypeStats));
 476     }
 477     else
 478     {
 479         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 480         request->ios2_WireError = S2WERR_NOT_TRACKED;
 481     }
 482
 483     /* Return */
 484
 485     return TRUE;
 486 }
 487
 488 static BOOL CmdGetTypeStats(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 489 {
 490     struct SiS900Unit *unit;
 491     struct Opener *opener;
 492     ULONG packet_type;
 493     struct TypeStats *initial_stats, *tracker;
 494     struct Sana2PacketTypeStats *stats;
 495
 496     unit = (APTR)request->ios2_Req.io_Unit;
 497
 498 D(bug("[%s]: S2CmdGetTypeStats()\n", unit->sis900u_name));
 499
 500     packet_type = request->ios2_PacketType;
 501
 502     /* Get global tracker and initial figures */
 503
 504     tracker = FindTypeStats(LIBBASE, unit, &unit->sis900u_type_trackers, packet_type);
 505     opener = request->ios2_BufferManagement;
 506     initial_stats = FindTypeStats(LIBBASE, unit, &opener->initial_stats, packet_type);
 507
 508     /* Copy and adjust figures */
 509     if(initial_stats != NULL)
 510     {
 511         stats = request->ios2_StatData;
 512         CopyMem(&tracker->stats, stats, sizeof(struct Sana2PacketTypeStats));
 513         stats->PacketsSent -= initial_stats->stats.PacketsSent;
 514         stats->PacketsReceived -= initial_stats->stats.PacketsReceived;
 515         stats->BytesSent -= initial_stats->stats.BytesSent;
 516         stats->BytesReceived -= initial_stats->stats.BytesReceived;
 517         stats->PacketsDropped -= initial_stats->stats.PacketsDropped;
 518     }
 519     else
 520     {
 521         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 522         request->ios2_WireError = S2WERR_NOT_TRACKED;
 523     }
 524
 525     /* Return */
 526
 527     return TRUE;
 528 }
 529
 530 static BOOL CmdGetGlobalStats(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 531 {
 532     struct SiS900Unit *unit;
 533
 534     /* Update and copy stats */
 535
 536     unit = (APTR)request->ios2_Req.io_Unit;
 537
 538 D(bug("[%s]: S2CmdGetGlobalStats()\n", unit->sis900u_name));
 539
 540     CopyMem(&unit->sis900u_stats, request->ios2_StatData,
 541         sizeof(struct Sana2DeviceStats));
 542
 543     /* Return */
 544
 545     return TRUE;
 546 }
 547
 548 static BOOL CmdDeviceQuery(LIBBASETYPEPTR LIBBASE, struct IOStdReq *request)
 549 {
 550     struct NSDeviceQueryResult *info;
 551
 552     /* Set structure size twice */
 553
 554     info = request->io_Data;
 555     request->io_Actual = info->SizeAvailable =
 556         offsetof(struct NSDeviceQueryResult, SupportedCommands) + sizeof(APTR);
 557
 558     /* Report device details */
 559
 560     info->DeviceType = NSDEVTYPE_SANA2;
 561     info->DeviceSubType = 0;
 562
 563     info->SupportedCommands = (APTR)supported_commands;
 564
 565     /* Return */
 566
 567     return TRUE;
 568 }
 569
 570 static BOOL CmdOnEvent(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 571 {
 572     struct SiS900Unit *unit;
 573     ULONG events, wanted_events;
 574     BOOL complete = FALSE;
 575
 576     /* Check if we understand the event types */
 577
 578     unit = (APTR)request->ios2_Req.io_Unit;
 579
 580 D(bug("[%s]: S2CmdOnEvent()\n", unit->sis900u_name));
 581
 582     wanted_events = request->ios2_WireError;
 583     if((wanted_events & ~KNOWN_EVENTS) != 0)
 584     {
 585         request->ios2_Req.io_Error = S2ERR_NOT_SUPPORTED;
 586         events = S2WERR_BAD_EVENT;
 587     }
 588     else
 589     {
 590         if((unit->sis900u_ifflags & IFF_UP) != 0)
 591             events = S2EVENT_ONLINE;
 592         else
 593             events = S2EVENT_OFFLINE;
 594
 595         events &= wanted_events;
 596     }
 597
 598     /* Reply request if a wanted event has already occurred */
 599
 600     if(events != 0)
 601     {
 602         request->ios2_WireError = events;
 603         complete = TRUE;
 604     }
 605     else
 606     {
 607         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 608         PutMsg(unit->sis900u_request_ports[EVENT_QUEUE], (APTR)request);
 609     }
 610
 611     /* Return */
 612
 613     return complete;
 614 }
 615
 616 static BOOL CmdReadOrphan(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 617 {
 618     struct SiS900Unit *unit;
 619     BYTE error = 0;
 620     ULONG wire_error;
 621     BOOL complete = FALSE;
 622
 623     /* Check request is valid */
 624
 625     unit = (APTR)request->ios2_Req.io_Unit;
 626 D(bug("[%s]: S2CmdReadOrphan()\n", unit->sis900u_name));
 627
 628     if((unit->sis900u_ifflags & IFF_UP) == 0)
 629     {
 630         error = S2ERR_OUTOFSERVICE;
 631         wire_error = S2WERR_UNIT_OFFLINE;
 632     }
 633
 634     /* Queue request */
 635
 636     if(error == 0)
 637     {
 638         request->ios2_Req.io_Flags &= ~IOF_QUICK;
 639         PutMsg(unit->sis900u_request_ports[ADOPT_QUEUE], (struct Message *)request);
 640     }
 641     else
 642     {
 643         request->ios2_Req.io_Error = error;
 644         request->ios2_WireError = wire_error;
 645         complete = TRUE;
 646     }
 647
 648     /* Return */
 649
 650     return complete;
 651 }
 652
 653 static BOOL CmdOnline(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 654 {
 655     struct SiS900Unit *unit = (struct SiS900Unit *)request->ios2_Req.io_Unit;
 656     BYTE error = 0;
 657     ULONG wire_error = 0;
 658     UWORD i;
 659
 660 D(bug("[%s]: S2CmdOnline()\n", unit->sis900u_name));
 661
 662     /* Check request is valid */
 663     if((unit->sis900u_ifflags & IFF_CONFIGURED) == 0)
 664     {
 665         error = S2ERR_BAD_STATE;
 666         wire_error = S2WERR_NOT_CONFIGURED;
 667     }
 668
 669     /* Clear global and special stats and put adapter back online */
 670
 671     if((error == 0) && ((unit->sis900u_ifflags & IFF_UP) == 0))
 672     {
 673         unit->sis900u_stats.PacketsReceived = 0;
 674         unit->sis900u_stats.PacketsSent = 0;
 675         unit->sis900u_stats.BadData = 0;
 676         unit->sis900u_stats.Overruns = 0;
 677         unit->sis900u_stats.UnknownTypesReceived = 0;
 678         unit->sis900u_stats.Reconfigurations = 0;
 679
 680         for(i = 0; i < SANA2_SPECIAL_STAT_COUNT; i++)
 681             unit->sis900u_special_stats[i] = 0;
 682
 683         if (sis900func_open(unit))
 684         {
 685             error = S2ERR_OUTOFSERVICE;
 686             wire_error = S2WERR_GENERIC_ERROR;
 687         }
 688     }
 689
 690     /* Return */
 691
 692     request->ios2_Req.io_Error = error;
 693     request->ios2_WireError = wire_error;
 694     return TRUE;
 695 }
 696
 697 static BOOL CmdOffline(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 698 {
 699     struct SiS900Unit *unit;
 700
 701     /* Put adapter offline */
 702
 703     unit = (APTR)request->ios2_Req.io_Unit;
 704
 705 D(bug("[%s]: S2CmdOffline()\n", unit->sis900u_name));
 706
 707     if((unit->sis900u_ifflags & IFF_UP) != 0)
 708         sis900func_close(unit);
 709
 710     /* Return */
 711     return TRUE;
 712 }
 713
 714 static BOOL CmdAddMulticastAddresses(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 715 {
 716     struct SiS900Unit *unit;
 717     UBYTE *lower_bound, *upper_bound;
 718
 719     unit = (APTR)request->ios2_Req.io_Unit;
 720
 721 D(bug("[%s]: S2CmdAddMulticastAddresses()\n", unit->sis900u_name));
 722
 723     lower_bound = request->ios2_SrcAddr;
 724     if(request->ios2_Req.io_Command == S2_ADDMULTICASTADDRESS)
 725         upper_bound = lower_bound;
 726     else
 727         upper_bound = request->ios2_DstAddr;
 728
 729     if(!AddMulticastRange(LIBBASE, unit, lower_bound, upper_bound))
 730     {
 731         request->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
 732         request->ios2_WireError = S2WERR_GENERIC_ERROR;
 733     }
 734
 735     /* Return */
 736
 737     return TRUE;
 738 }
 739
 740 static BOOL CmdDelMulticastAddresses(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 741 {
 742     struct SiS900Unit *unit;
 743     UBYTE *lower_bound, *upper_bound;
 744
 745     unit = (APTR)request->ios2_Req.io_Unit;
 746
 747 D(bug("[%s]: S2CmdDelMulticastAddresses()\n", unit->sis900u_name));
 748
 749     lower_bound = request->ios2_SrcAddr;
 750     if(request->ios2_Req.io_Command == S2_DELMULTICASTADDRESS)
 751         upper_bound = lower_bound;
 752     else
 753         upper_bound = request->ios2_DstAddr;
 754
 755     if(!RemMulticastRange(LIBBASE, unit, lower_bound, upper_bound))
 756     {
 757         request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 758         request->ios2_WireError = S2WERR_BAD_MULTICAST;
 759     }
 760
 761     /* Return */
 762
 763     return TRUE;
 764 }