workbench/devs/networks/e1000/handler.c

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