workbench/devs/networks/emac/handler.c

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