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