workbench/devs/networks/rtl8169/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 "rtl8169.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     {
 186                 ReplyMsg((APTR)request);
 187         }
 188     ReleaseSemaphore(&((struct RTL8169Unit *)request->ios2_Req.io_Unit)->rtl8169u_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 RTL8169Unit *unit;
 202     struct Opener *opener;
 203     // BYTE error = 0;
 204     // ULONG wire_error = S2WERR_GENERIC_ERROR;
 205     BOOL complete = FALSE;
 206
 207     unit = (APTR) request->ios2_Req.io_Unit;
 208
 209     RTLD(bug("[%s] S2CmdRead()\n", unit->rtl8169u_name))
 210
 211     if((unit->rtl8169u_flags & IFF_UP) != 0)
 212     {
 213                 opener = request->ios2_BufferManagement;
 214                 request->ios2_Req.io_Flags &= ~IOF_QUICK;
 215                 PutMsg(&opener->read_port, (struct Message *) request);
 216     }
 217     else
 218     {
 219                 request->ios2_Req.io_Error = S2ERR_OUTOFSERVICE;
 220                 request->ios2_WireError = S2WERR_UNIT_OFFLINE;
 221                 complete = TRUE;
 222     }
 223
 224     /* Return */
 225
 226     return complete;
 227 }
 228
 229 static BOOL CmdWrite(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 230 {
 231     struct RTL8169Unit *unit;
 232     BYTE error = 0;
 233     ULONG wire_error = S2WERR_GENERIC_ERROR;
 234     BOOL complete = FALSE;
 235
 236     /* Check request is valid */
 237
 238     unit = (APTR) request->ios2_Req.io_Unit;
 239
 240     RTLD(bug("[%s] S2CmdWrite()\n", unit->rtl8169u_name))
 241
 242     if((unit->rtl8169u_flags & IFF_UP) == 0)
 243     {
 244                 error = S2ERR_OUTOFSERVICE;
 245                 wire_error = S2WERR_UNIT_OFFLINE;
 246     }
 247     else if((request->ios2_Req.io_Command == S2_MULTICAST) &&
 248                    ((request->ios2_DstAddr[0] & 0x1) == 0))
 249     {
 250                 error = S2ERR_BAD_ADDRESS;
 251                 wire_error = S2WERR_BAD_MULTICAST;
 252     }
 253
 254     /* Queue request for sending */
 255
 256     if(error == 0)
 257     {
 258                 request->ios2_Req.io_Flags &= ~IOF_QUICK;
 259                 PutMsg(unit->rtl8169u_request_ports[WRITE_QUEUE], (APTR)request);
 260     }
 261     else
 262     {
 263                 request->ios2_Req.io_Error = error;
 264                 request->ios2_WireError = wire_error;
 265                 complete = TRUE;
 266     }
 267
 268     /* Return */
 269
 270     return complete;
 271 }
 272
 273 static BOOL CmdFlush(LIBBASETYPEPTR LIBBASE, struct IORequest *request)
 274 {
 275     FlushUnit(LIBBASE, (APTR)request->io_Unit, EVENT_QUEUE, IOERR_ABORTED);
 276     return TRUE;
 277 }
 278
 279 static BOOL CmdS2DeviceQuery(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 280 {
 281     struct RTL8169Unit *unit = (APTR)request->ios2_Req.io_Unit;
 282     // struct rtl8169_priv *np = unit->rtl8169u_priv;
 283     struct Sana2DeviceQuery *info;
 284     ULONG size_available, size;
 285
 286     RTLD(bug("[%s] S2CmdDeviceQuery()\n", unit->rtl8169u_name))
 287
 288     /* Copy device info */
 289
 290     info = request->ios2_StatData;
 291     size = size_available = info->SizeAvailable;
 292     if(size > sizeof(struct Sana2DeviceQuery))
 293         size = sizeof(struct Sana2DeviceQuery);
 294
 295     CopyMem(&unit->rtl8169u_Sana2Info, info, size);
 296
 297     info->BPS = unit->rtl8169u_rtl_LinkSpeed;
 298     info->MTU = ETH_MTU;
 299     info->HardwareType = S2WireType_Ethernet;
 300     info->SizeAvailable = size_available;
 301     info->SizeSupplied = size;
 302
 303     /* Return */
 304
 305     return TRUE;
 306 }
 307
 308 static BOOL CmdGetStationAddress(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 309 {
 310     struct RTL8169Unit *unit;
 311
 312     /* Copy addresses */
 313
 314     unit = (APTR)request->ios2_Req.io_Unit;
 315
 316     RTLD(bug("[%s] S2CmdGetStationAddress()\n", unit->rtl8169u_name))
 317
 318     CopyMem(unit->rtl8169u_dev_addr, request->ios2_SrcAddr, ETH_ADDRESSSIZE);
 319     CopyMem(unit->rtl8169u_org_addr, request->ios2_DstAddr, ETH_ADDRESSSIZE);
 320
 321     /* Return */
 322
 323     return TRUE;
 324 }
 325
 326 static BOOL CmdConfigInterface(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 327 {
 328     struct RTL8169Unit *unit;
 329
 330     /* Configure adapter */
 331
 332     unit = (APTR)request->ios2_Req.io_Unit;
 333
 334     RTLD(bug("[%s] S2CmdConfigInterface()\n", unit->rtl8169u_name))
 335
 336     if((unit->rtl8169u_flags & IFF_CONFIGURED) == 0)
 337     {
 338             CopyMem(request->ios2_SrcAddr, unit->rtl8169u_dev_addr, ETH_ADDRESSSIZE);
 339             unit->set_mac_address(unit);
 340             unit->rtl8169u_flags |= IFF_CONFIGURED;
 341     }
 342     else
 343     {
 344             request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 345             request->ios2_WireError = S2WERR_IS_CONFIGURED;
 346     }
 347
 348     /* Return */
 349
 350     return TRUE;
 351 }
 352
 353 static BOOL CmdBroadcast(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 354 {
 355     /* Fill in the broadcast address as destination */
 356
 357     memset(request->ios2_DstAddr, 0xff, 6);
 358
 359     /* Queue the write as normal */
 360
 361     return CmdWrite(LIBBASE, request);
 362 }
 363
 364 static BOOL CmdTrackType(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 365 {
 366     struct RTL8169Unit *unit;
 367     struct Opener *opener;
 368     ULONG packet_type, wire_error=0;
 369     struct TypeTracker *tracker;
 370     struct TypeStats *initial_stats;
 371     BYTE error = 0;
 372
 373     unit = (APTR)request->ios2_Req.io_Unit;
 374
 375     RTLD(bug("[%s] S2CmdTrackType()\n", unit->rtl8169u_name))
 376
 377     packet_type = request->ios2_PacketType;
 378
 379     /* Get global tracker */
 380
 381     tracker = (struct TypeTracker *)
 382         FindTypeStats(LIBBASE, unit, &unit->rtl8169u_type_trackers, packet_type);
 383
 384     if(tracker != NULL)
 385     {
 386                 tracker->user_count++;
 387         }
 388     else
 389     {
 390                 tracker = AllocMem(sizeof(struct TypeTracker), MEMF_PUBLIC | MEMF_CLEAR);
 391                 if(tracker != NULL)
 392                 {
 393                     tracker->packet_type = packet_type;
 394                     tracker->user_count = 1;
 395
 396                     Disable();
 397                     AddTail((APTR)&unit->rtl8169u_type_trackers, (APTR)tracker);
 398                     Enable();
 399                 }
 400         }
 401
 402     /* Store initial figures for this opener */
 403
 404     opener = request->ios2_BufferManagement;
 405     initial_stats = FindTypeStats(LIBBASE, unit, &opener->initial_stats, packet_type);
 406
 407     if(initial_stats != NULL)
 408     {
 409                 error = S2ERR_BAD_STATE;
 410                 wire_error = S2WERR_ALREADY_TRACKED;
 411     }
 412
 413     if(error == 0)
 414     {
 415                 initial_stats = AllocMem(sizeof(struct TypeStats), MEMF_PUBLIC);
 416                 if(initial_stats == NULL)
 417                 {
 418                     error = S2ERR_NO_RESOURCES;
 419                     wire_error = S2WERR_GENERIC_ERROR;
 420                 }
 421     }
 422
 423     if(error == 0)
 424     {
 425                 CopyMem(tracker, initial_stats, sizeof(struct TypeStats));
 426                 AddTail((APTR)&opener->initial_stats, (APTR)initial_stats);
 427     }
 428
 429     /* Return */
 430
 431     request->ios2_Req.io_Error = error;
 432     request->ios2_WireError = wire_error;
 433     return TRUE;
 434 }
 435
 436 static BOOL CmdUntrackType(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 437 {
 438     struct RTL8169Unit *unit;
 439     struct Opener *opener;
 440     ULONG packet_type;
 441     struct TypeTracker *tracker;
 442     struct TypeStats *initial_stats;
 443
 444     unit = (APTR)request->ios2_Req.io_Unit;
 445
 446     RTLD(bug("[%s] S2CmdUntrackType()\n", unit->rtl8169u_name))
 447
 448     packet_type = request->ios2_PacketType;
 449
 450     /* Get global tracker and initial figures */
 451
 452     tracker = (struct TypeTracker *)
 453                   FindTypeStats(LIBBASE, unit, &unit->rtl8169u_type_trackers, packet_type);
 454     opener = request->ios2_BufferManagement;
 455     initial_stats = FindTypeStats(LIBBASE, unit, &opener->initial_stats, packet_type);
 456
 457     /* Decrement tracker usage and free unused structures */
 458
 459     if(initial_stats != NULL)
 460     {
 461                 if((--tracker->user_count) == 0)
 462                 {
 463                     Disable();
 464                     Remove((APTR)tracker);
 465                     Enable();
 466                     FreeMem(tracker, sizeof(struct TypeTracker));
 467                 }
 468
 469                 Remove((APTR)initial_stats);
 470                 FreeMem(initial_stats, sizeof(struct TypeStats));
 471     }
 472     else
 473     {
 474                 request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 475                 request->ios2_WireError = S2WERR_NOT_TRACKED;
 476     }
 477
 478     /* Return */
 479
 480     return TRUE;
 481 }
 482
 483 static BOOL CmdGetTypeStats(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 484 {
 485     struct RTL8169Unit *unit;
 486     struct Opener *opener;
 487     ULONG packet_type;
 488     struct TypeStats *initial_stats, *tracker;
 489     struct Sana2PacketTypeStats *stats;
 490
 491     unit = (APTR)request->ios2_Req.io_Unit;
 492
 493     RTLD(bug("[%s] S2CmdGetTypeStats()\n", unit->rtl8169u_name))
 494
 495     packet_type = request->ios2_PacketType;
 496
 497     /* Get global tracker and initial figures */
 498
 499     tracker = FindTypeStats(LIBBASE, unit, &unit->rtl8169u_type_trackers, packet_type);
 500     opener = request->ios2_BufferManagement;
 501     initial_stats = FindTypeStats(LIBBASE, unit, &opener->initial_stats, packet_type);
 502
 503     /* Copy and adjust figures */
 504     if(initial_stats != NULL)
 505     {
 506                 stats = request->ios2_StatData;
 507                 CopyMem(&tracker->stats, stats, sizeof(struct Sana2PacketTypeStats));
 508                 stats->PacketsSent -= initial_stats->stats.PacketsSent;
 509                 stats->PacketsReceived -= initial_stats->stats.PacketsReceived;
 510                 stats->BytesSent -= initial_stats->stats.BytesSent;
 511                 stats->BytesReceived -= initial_stats->stats.BytesReceived;
 512                 stats->PacketsDropped -= initial_stats->stats.PacketsDropped;
 513     }
 514     else
 515     {
 516                 request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 517                 request->ios2_WireError = S2WERR_NOT_TRACKED;
 518     }
 519
 520     /* Return */
 521
 522     return TRUE;
 523 }
 524
 525 static BOOL CmdGetGlobalStats(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 526 {
 527     struct RTL8169Unit *unit;
 528
 529     /* Update and copy stats */
 530
 531     unit = (APTR)request->ios2_Req.io_Unit;
 532
 533     RTLD(bug("[%s] S2CmdGetGlobalStats()\n", unit->rtl8169u_name))
 534
 535     CopyMem(&unit->rtl8169u_stats, request->ios2_StatData,
 536                 sizeof(struct Sana2DeviceStats));
 537
 538     /* Return */
 539
 540     return TRUE;
 541 }
 542
 543 static BOOL CmdDeviceQuery(LIBBASETYPEPTR LIBBASE, struct IOStdReq *request)
 544 {
 545     struct NSDeviceQueryResult *info;
 546
 547     /* Set structure size twice */
 548
 549     info = request->io_Data;
 550     request->io_Actual = info->SizeAvailable =
 551                                                  offsetof(struct NSDeviceQueryResult, SupportedCommands) + sizeof(APTR);
 552
 553     /* Report device details */
 554
 555     info->DeviceType = NSDEVTYPE_SANA2;
 556     info->DeviceSubType = 0;
 557
 558     info->SupportedCommands = (APTR)supported_commands;
 559
 560     /* Return */
 561
 562     return TRUE;
 563 }
 564
 565 static BOOL CmdOnEvent(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 566 {
 567     struct RTL8169Unit *unit;
 568     ULONG events, wanted_events;
 569     BOOL complete = FALSE;
 570
 571     /* Check if we understand the event types */
 572
 573     unit = (APTR)request->ios2_Req.io_Unit;
 574
 575     RTLD(bug("[%s] S2CmdOnEvent()\n", unit->rtl8169u_name))
 576
 577     wanted_events = request->ios2_WireError;
 578     if((wanted_events & ~KNOWN_EVENTS) != 0)
 579     {
 580                 request->ios2_Req.io_Error = S2ERR_NOT_SUPPORTED;
 581                 events = S2WERR_BAD_EVENT;
 582     }
 583     else
 584     {
 585                 if((unit->rtl8169u_flags & IFF_UP) != 0)
 586                 {
 587                     events = S2EVENT_ONLINE;
 588                 }
 589                 else
 590                 {
 591                     events = S2EVENT_OFFLINE;
 592                 }
 593
 594                 events &= wanted_events;
 595     }
 596
 597     /* Reply request if a wanted event has already occurred */
 598
 599     if(events != 0)
 600     {
 601                 request->ios2_WireError = events;
 602                 complete = TRUE;
 603     }
 604     else
 605     {
 606                 request->ios2_Req.io_Flags &= ~IOF_QUICK;
 607                 PutMsg(unit->rtl8169u_request_ports[EVENT_QUEUE], (APTR)request);
 608     }
 609
 610     /* Return */
 611
 612     return complete;
 613 }
 614
 615 static BOOL CmdReadOrphan(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 616 {
 617     struct RTL8169Unit *unit;
 618     BYTE error = 0;
 619     ULONG wire_error;
 620     BOOL complete = FALSE;
 621
 622     /* Check request is valid */
 623
 624     unit = (APTR)request->ios2_Req.io_Unit;
 625     RTLD(bug("[%s] S2CmdReadOrphan()\n", unit->rtl8169u_name))
 626
 627     if((unit->rtl8169u_flags & IFF_UP) == 0)
 628     {
 629                 error = S2ERR_OUTOFSERVICE;
 630                 wire_error = S2WERR_UNIT_OFFLINE;
 631     }
 632
 633     /* Queue request */
 634
 635     if(error == 0)
 636     {
 637                 request->ios2_Req.io_Flags &= ~IOF_QUICK;
 638                 PutMsg(unit->rtl8169u_request_ports[ADOPT_QUEUE], (struct Message *) request);
 639     }
 640     else
 641     {
 642                 request->ios2_Req.io_Error = error;
 643                 request->ios2_WireError = wire_error;
 644                 complete = TRUE;
 645     }
 646
 647     /* Return */
 648
 649     return complete;
 650 }
 651
 652 static BOOL CmdOnline(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 653 {
 654     struct RTL8169Unit *unit = (struct RTL8169Unit *)request->ios2_Req.io_Unit;
 655     BYTE error = 0;
 656     ULONG wire_error = 0;
 657     UWORD i;
 658
 659     RTLD(bug("[%s] S2CmdOnline()\n", unit->rtl8169u_name))
 660
 661     /* Check request is valid */
 662     if((unit->rtl8169u_flags & IFF_CONFIGURED) == 0)
 663     {
 664                 error = S2ERR_BAD_STATE;
 665                 wire_error = S2WERR_NOT_CONFIGURED;
 666     }
 667
 668     /* Clear global and special stats and put adapter back online */
 669
 670     if((error == 0) && ((unit->rtl8169u_flags & IFF_UP) == 0))
 671     {
 672                 unit->rtl8169u_stats.PacketsReceived = 0;
 673                 unit->rtl8169u_stats.PacketsSent = 0;
 674                 unit->rtl8169u_stats.BadData = 0;
 675                 unit->rtl8169u_stats.Overruns = 0;
 676                 unit->rtl8169u_stats.UnknownTypesReceived = 0;
 677                 unit->rtl8169u_stats.Reconfigurations = 0;
 678
 679                 for(i = 0; i < STAT_COUNT; i++)
 680                 {
 681                     unit->rtl8169u_special_stats[i] = 0;
 682                 }
 683
 684                 if (unit->start(unit))
 685                 {
 686                 error = S2ERR_OUTOFSERVICE;
 687                 wire_error = S2WERR_GENERIC_ERROR;
 688                 }
 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 RTL8169Unit *unit;
 701
 702     /* Put adapter offline */
 703
 704     unit = (APTR)request->ios2_Req.io_Unit;
 705
 706     RTLD(bug("[%s] S2CmdOffline()\n", unit->rtl8169u_name))
 707
 708     if((unit->rtl8169u_flags & IFF_UP) != 0)
 709     {
 710                 unit->stop(unit);
 711         }
 712
 713     /* Return */
 714     return TRUE;
 715 }
 716
 717 static BOOL CmdAddMulticastAddresses(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 718 {
 719     struct RTL8169Unit *unit;
 720     UBYTE *lower_bound, *upper_bound;
 721
 722     unit = (APTR)request->ios2_Req.io_Unit;
 723
 724     RTLD(bug("[%s] S2CmdAddMulticastAddresses()\n", unit->rtl8169u_name))
 725
 726     lower_bound = request->ios2_SrcAddr;
 727     if(request->ios2_Req.io_Command == S2_ADDMULTICASTADDRESS)
 728         upper_bound = lower_bound;
 729     else
 730         upper_bound = request->ios2_DstAddr;
 731
 732     if(!AddMulticastRange(LIBBASE, unit, lower_bound, upper_bound))
 733     {
 734             request->ios2_Req.io_Error = S2ERR_NO_RESOURCES;
 735             request->ios2_WireError = S2WERR_GENERIC_ERROR;
 736     }
 737
 738     /* Return */
 739
 740     return TRUE;
 741 }
 742
 743 static BOOL CmdDelMulticastAddresses(LIBBASETYPEPTR LIBBASE, struct IOSana2Req *request)
 744 {
 745     struct RTL8169Unit *unit;
 746     UBYTE *lower_bound, *upper_bound;
 747
 748     unit = (APTR)request->ios2_Req.io_Unit;
 749
 750     RTLD(bug("[%s] S2CmdDelMulticastAddresses()\n", unit->rtl8169u_name))
 751
 752     lower_bound = request->ios2_SrcAddr;
 753     if(request->ios2_Req.io_Command == S2_DELMULTICASTADDRESS)
 754     {
 755                 upper_bound = lower_bound;
 756         }
 757     else
 758         {
 759                 upper_bound = request->ios2_DstAddr;
 760         }
 761
 762     if(!RemMulticastRange(LIBBASE, unit, lower_bound, upper_bound))
 763     {
 764                 request->ios2_Req.io_Error = S2ERR_BAD_STATE;
 765                 request->ios2_WireError = S2WERR_BAD_MULTICAST;
 766     }
 767
 768     /* Return */
 769
 770     return TRUE;
 771 }