rom/usb/classes/rndis/dev.c

   1 /*
   2  * $Id$
   3  */
   4
   5 #include "debug.h"
   6
   7 #include "rndis.class.h"
   8
   9 AROS_UFH3(DEVBASETYPEPTR, devInit,
  10           AROS_UFHA(DEVBASETYPEPTR, base, D0),
  11           AROS_UFHA(BPTR, seglist, A0),
  12           AROS_UFHA(struct ExecBase *, SysBase, A6))
  13 {
  14     AROS_USERFUNC_INIT
  15
  16     KPRINTF(10, ("devInit base: 0x%08lx seglist: 0x%08lx SysBase: 0x%08lx\n",
  17                  base, seglist, SysBase));
  18
  19     base->np_Library.lib_Node.ln_Type = NT_DEVICE;
  20     base->np_Library.lib_Node.ln_Name = DEVNAME;
  21     base->np_Library.lib_Flags        = LIBF_SUMUSED|LIBF_CHANGED;
  22     base->np_Library.lib_Version      = VERSION_NUMBER;
  23     base->np_Library.lib_Revision     = REVISION_NUMBER;
  24     base->np_Library.lib_IdString     = VERSION_STRING;
  25
  26     /* Store segment */
  27     base->np_SegList = seglist;
  28
  29     if((base->np_UtilityBase = OpenLibrary("utility.library", 0)))
  30     {
  31         KPRINTF(10, ("devInit: Ok\n"));
  32         KPRINTF(10, ("devInit: openCnt = %ld\n", base->np_Library.lib_OpenCnt));
  33         return(base);
  34     }
  35     else
  36     {
  37         return(NULL);
  38     }
  39     return(base);
  40
  41     AROS_USERFUNC_EXIT
  42 }
  43
  44 #undef UtilityBase
  45 #define UtilityBase     base->np_UtilityBase
  46
  47 AROS_LH3(DEVBASETYPEPTR, devOpen,
  48          AROS_LHA(struct IOSana2Req *, ioreq, A1),
  49          AROS_LHA(ULONG, unit, D0),
  50          AROS_LHA(ULONG, flags, D1),
  51          DEVBASETYPEPTR, base, 1, dev)
  52 {
  53     AROS_LIBFUNC_INIT
  54
  55     struct NepClassEth *ncp;
  56     struct TagItem *taglist;
  57
  58     KPRINTF(10, ("devOpen ioreq: 0x%08lx unit: %ld flags: 0x%08lx base: 0x%08lx\n",
  59                  ioreq, unit, flags, base));
  60
  61     ++base->np_Library.lib_OpenCnt;
  62     base->np_Library.lib_Flags &= ~LIBF_DELEXP;
  63
  64     KPRINTF(10, ("devOpen: openCnt = %ld\n", base->np_Library.lib_OpenCnt));
  65     /* Damn f*cking programs which leave this field to zero! */
  66     if(ioreq->ios2_Req.io_Message.mn_Length && (ioreq->ios2_Req.io_Message.mn_Length < sizeof(struct IOSana2Req)))
  67     {
  68         KPRINTF(20, ("devOpen: invalid MN_LENGTH (%ld < %ld)!\n",
  69                 ioreq->ios2_Req.io_Message.mn_Length, sizeof(struct IOSana2Req)));
  70
  71         ioreq->ios2_Req.io_Error = IOERR_BADLENGTH;
  72     } else {
  73         /* Default to open failure. */
  74         ioreq->ios2_Req.io_Error = IOERR_OPENFAIL;
  75
  76         ioreq->ios2_Req.io_Unit = NULL;
  77         ncp = (struct NepClassEth *) base->np_ClsBase->nh_Units.lh_Head;
  78         while(ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ)
  79         {
  80             if(ncp->ncp_UnitNo == unit)
  81             {
  82                 if(ncp->ncp_OpenFlags & SANA2OPF_MINE)
  83                 {
  84                     ioreq->ios2_Req.io_Error = IOERR_UNITBUSY;
  85                 } else {
  86                     ioreq->ios2_Req.io_Unit = (struct Unit *) ncp;
  87                 }
  88                 break;
  89             }
  90             ncp = (struct NepClassEth *) ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ;
  91         }
  92
  93         if(!ioreq->ios2_Req.io_Unit)
  94         {
  95             ioreq->ios2_Req.io_Error = IOERR_OPENFAIL;
  96             KPRINTF(20, ("devOpen: could not open unit!\n"));
  97         } else {
  98             ncp->ncp_OpenFlags |= flags;
  99
 100             /* Got taglist? (don't fail if not available!) */
 101             taglist = (struct TagItem *) ioreq->ios2_BufferManagement;
 102             if(taglist)
 103             {
 104                 struct BufMan *bufman;
 105
 106                 bufman = (struct BufMan *) AllocVec(sizeof(struct BufMan), MEMF_CLEAR|MEMF_PUBLIC);
 107                 if(bufman)
 108                 {
 109                     /* Get copyfrom routines */
 110                     bufman->bm_CopyFromBuf = (APTR) GetTagData(S2_CopyFromBuff, (IPTR) NULL, taglist);
 111                     bufman->bm_CopyToBuf   = (APTR) GetTagData(S2_CopyToBuff, (IPTR) NULL, taglist);
 112
 113                     /* This is new SANA-II V2 addition */
 114                     bufman->bm_PacketFilter = (APTR) GetTagData(S2_PacketFilter, (IPTR) NULL, taglist);
 115
 116                     /* These are new SANA-II V3 addition */
 117                     bufman->bm_DMACopyFromBuf32 = (APTR) GetTagData(S2_DMACopyFromBuff32, (IPTR) NULL, taglist);
 118                     bufman->bm_DMACopyToBuf32   = (APTR) GetTagData(S2_DMACopyToBuff32, (IPTR) NULL, taglist);
 119
 120                     /* Init the list for CMD_READ requests */
 121                     NewList((struct List *) &bufman->bm_RXQueue);
 122
 123                     /* Add the new bufman to global bufmanlist */
 124                     KPRINTF(5, ("Open_Unit: added bufman at 0x%08lx\n", bufman));
 125                     Forbid();
 126                     AddHead((struct List *) &ncp->ncp_BufManList, (struct Node *) bufman);
 127                     Permit();
 128
 129                     ioreq->ios2_BufferManagement = bufman;
 130                 }
 131                 KPRINTF(5, ("Open_Unit:\n"
 132                             "copyfrombuf: 0x%08lx copytobuf: 0x%08lx packetfilter: 0x%08lx\n"
 133                             "dmacopyfrombuf32: 0x%08lx dmacopytobuf32: 0x%08lx\n",
 134                             bufman->bm_CopyFromBuf, bufman->bm_CopyToBuf, bufman->bm_PacketFilter,
 135                             bufman->bm_DMACopyFromBuf32, bufman->bm_DMACopyToBuf32));
 136             }
 137             /* Opended ok! */
 138             ioreq->ios2_Req.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
 139             ioreq->ios2_Req.io_Error                   = 0;
 140             ioreq->ios2_Req.io_Unit->unit_OpenCnt++;
 141
 142             /* Allow queuing */
 143             //ncp->ncp_DenyRequests = FALSE;
 144
 145             return base;
 146         }
 147     }
 148
 149     ioreq->ios2_Req.io_Unit   = (APTR) -1;
 150     ioreq->ios2_Req.io_Device = (APTR) -1;
 151     base->np_Library.lib_OpenCnt--;
 152
 153     return(NULL);
 154
 155     AROS_LIBFUNC_EXIT
 156 }
 157
 158
 159 AROS_LH1(BPTR, devClose,
 160          AROS_LHA(struct IOSana2Req *, ioreq, A1),
 161          DEVBASETYPEPTR, base, 2, dev)
 162 {
 163     AROS_LIBFUNC_INIT
 164
 165     BPTR ret;
 166     struct NepClassEth *ncp = (struct NepClassEth *) ioreq->ios2_Req.io_Unit;
 167     struct BufMan *bufman;
 168
 169     KPRINTF(10, ("devClose ioreq: 0x%08lx base: 0x%08lx\n", ioreq, base));
 170
 171     ret = BNULL;
 172     /* Allow queuing */
 173     //ncp->ncp_DenyRequests = TRUE;
 174
 175     ncp->ncp_Unit.unit_OpenCnt--;
 176     if(ncp->ncp_Unit.unit_OpenCnt == 1)
 177     {
 178         ncp->ncp_OpenFlags = 0; // clear all flags, if all units are closed
 179     }
 180
 181     ioreq->ios2_Req.io_Unit   = (APTR) -1;
 182     ioreq->ios2_Req.io_Device = (APTR) -1;
 183
 184     bufman = ioreq->ios2_BufferManagement;
 185     if(bufman)
 186     {
 187         KPRINTF(5, ("Close_Unit: remove bufman at 0x%08lx\n", bufman));
 188         ioreq->ios2_BufferManagement = NULL;
 189
 190         Forbid();
 191         Remove((struct Node *) bufman);
 192         Permit();
 193         FreeVec(bufman);
 194     }
 195
 196     if(--base->np_Library.lib_OpenCnt == 0)
 197     {
 198         if(base->np_Library.lib_Flags & LIBF_DELEXP)
 199         {
 200             KPRINTF(5, ("devClose: calling expunge...\n"));
 201             ret = AROS_LC1(BPTR, devExpunge,
 202                            AROS_LCA(DEVBASETYPEPTR, base, D0),
 203                            DEVBASETYPEPTR, base, 3, dev);
 204         }
 205     }
 206
 207     KPRINTF(5, ("devClose: lib_OpenCnt = %ld\n", base->np_Library.lib_OpenCnt));
 208
 209     return(ret);
 210
 211     AROS_LIBFUNC_EXIT
 212 }
 213
 214
 215 AROS_LH1(BPTR, devExpunge,
 216          AROS_LHA(DEVBASETYPEPTR, extralh, D0),
 217          DEVBASETYPEPTR, base, 3, dev)
 218 {
 219     AROS_LIBFUNC_INIT
 220
 221     BPTR ret;
 222
 223     KPRINTF(10, ("devExpunge base: 0x%08lx\n", base));
 224
 225     ret = BNULL;
 226
 227     if(base->np_Library.lib_OpenCnt == 0)
 228     {
 229         KPRINTF(5, ("devExpunge: Unloading...\n"));
 230
 231         CloseLibrary(base->np_UtilityBase);
 232
 233         ret = base->np_SegList;
 234
 235         KPRINTF(5, ("devExpunge: removing device node 0x%08lx\n",
 236                     &base->np_Library.lib_Node));
 237         Remove(&base->np_Library.lib_Node);
 238
 239         KPRINTF(5, ("devExpunge: FreeMem()...\n"));
 240         FreeMem((char *) base - base->np_Library.lib_NegSize,
 241                 (ULONG) (base->np_Library.lib_NegSize + base->np_Library.lib_PosSize));
 242
 243         KPRINTF(5, ("devExpunge: Unloading done! " DEVNAME " expunged!\n\n"));
 244
 245         return(ret);
 246     }
 247     else
 248     {
 249         KPRINTF(5, ("devExpunge: Could not expunge, LIBF_DELEXP set!\n"));
 250         base->np_Library.lib_Flags |= LIBF_DELEXP;
 251     }
 252
 253     return(BNULL);
 254
 255     AROS_LIBFUNC_EXIT
 256 }
 257
 258 AROS_LH0(DEVBASETYPEPTR, devReserved,
 259          DEVBASETYPEPTR, base, 4, dev)
 260 {
 261     AROS_LIBFUNC_INIT
 262     return NULL;
 263     AROS_LIBFUNC_EXIT
 264 }
 265
 266
 267 /*
 268  *======================================================================
 269  * cmdRead(ioreq, base)
 270  *======================================================================
 271  *
 272  * This is the device CMD_READ routine.
 273  *
 274  * First it check if nic is in proper state and if user passed arguments
 275  * are valid. If everything is ok, the request is linked to queue of
 276  * pending read requests.
 277  *
 278  * The request is replied only when packet matching it's ios2_PacketType
 279  * arrive, or if user abort the request with AbortIO().
 280  *
 281  */
 282
 283 WORD cmdRead(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 284 {
 285     struct BufMan *bufman;
 286     KPRINTF(1, ("CMD_READ ioreq: 0x%08lx type: %lu\n", ioreq, ioreq->ios2_PacketType));
 287
 288     /* Configured? */
 289     if(!(ncp->ncp_StateFlags & DDF_CONFIGURED))
 290     {
 291         return deverror(S2ERR_BAD_STATE, S2WERR_NOT_CONFIGURED);
 292     }
 293
 294     /* Online? */
 295     if(!(ncp->ncp_StateFlags & DDF_ONLINE))
 296     {
 297         return deverror(S2ERR_OUTOFSERVICE, S2WERR_UNIT_OFFLINE);
 298     }
 299
 300     /* Valid bufman? Got copytobuf routine? */
 301     bufman = ioreq->ios2_BufferManagement;
 302     if((!bufman) || (!bufman->bm_CopyToBuf))
 303     {
 304         return deverror(S2ERR_BAD_ARGUMENT, S2WERR_NULL_POINTER);
 305     }
 306
 307     /* Must be queued */
 308     ioreq->ios2_Req.io_Flags &= ~IOF_QUICK;
 309
 310     /* Add to this ioreq's bufman rxqueue */
 311     Forbid();
 312     AddTail((struct List *) &bufman->bm_RXQueue, (struct Node *) ioreq);
 313     Permit();
 314     /* Don't reply the ioreq, it's pending
 315     */
 316     return RC_DONTREPLY;
 317 }
 318
 319
 320 /*
 321  *======================================================================
 322  * cmdWrite(ioreq, base)
 323  *======================================================================
 324  *
 325  * This is the device CMD_WRITE routine.
 326  *
 327  * First it check if nic is in proper state and if user passed arguments
 328  * are valid. If everything is ok, the request is linked to queue of
 329  * pending write requests.
 330  *
 331  * The request is replied as soon as the write has been processed or if
 332  * user abort the request with AbortIO().
 333  *
 334  */
 335
 336 WORD cmdWrite(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 337 {
 338     struct BufMan *bufman;
 339     int size;
 340
 341     KPRINTF(1, ("CMD_WRITE ioreq: 0x%08lx type: %lu len: %lu\n",
 342                 ioreq, ioreq->ios2_PacketType, ioreq->ios2_DataLength));
 343
 344     /* Configured? */
 345     if(!(ncp->ncp_StateFlags & DDF_CONFIGURED))
 346     {
 347         return deverror(S2ERR_BAD_STATE, S2WERR_NOT_CONFIGURED);
 348     }
 349
 350     /* Online? */
 351     if(!(ncp->ncp_StateFlags & DDF_ONLINE))
 352     {
 353         return deverror(S2ERR_OUTOFSERVICE, S2WERR_UNIT_OFFLINE);
 354     }
 355
 356     /* Valid bufman? got copyfrombuf routine? */
 357     bufman = ioreq->ios2_BufferManagement;
 358     if((!bufman) || (!bufman->bm_CopyFromBuf))
 359     {
 360         return deverror(S2ERR_BAD_ARGUMENT, S2WERR_NULL_POINTER);
 361     }
 362
 363     /* Check packet size */
 364     size = (ioreq->ios2_Req.io_Flags & SANA2IOF_RAW) ? RAWPKT_SIZE : ETHERPKT_SIZE;
 365     if(ioreq->ios2_DataLength > size)
 366     {
 367         /* Trigger any tx or generic error events */
 368         nDoEvent(ncp, S2EVENT_ERROR|S2EVENT_TX);
 369         return deverror(S2ERR_MTU_EXCEEDED, S2WERR_GENERIC_ERROR);
 370     }
 371
 372     /* Must be queued */
 373     ioreq->ios2_Req.io_Flags &= ~IOF_QUICK;
 374     Forbid();
 375     AddTail(&ncp->ncp_WriteQueue, &ioreq->ios2_Req.io_Message.mn_Node);
 376     if(ncp->ncp_Unit.unit_MsgPort.mp_SigTask)
 377     {
 378         Signal(ncp->ncp_Unit.unit_MsgPort.mp_SigTask, 1L<<(ncp->ncp_Unit.unit_MsgPort.mp_SigBit));
 379     }
 380     Permit();
 381     /* Don't reply the ioreq, it's pending */
 382     return RC_DONTREPLY;
 383 }
 384
 385
 386 /*
 387  *======================================================================
 388  * cmdFlush(ioreq, base)
 389  *======================================================================
 390  *
 391  * This is the device CMD_FLUSH routine.
 392  *
 393  * This routine abort all pending read, write and event requests.
 394  *
 395  */
 396
 397 WORD cmdFlush(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 398 {
 399     struct BufMan *bufman;
 400
 401     KPRINTF(1, ("CMD_FLUSH ioreq: 0x%08lx\n", ioreq));
 402
 403     bufman = ioreq->ios2_BufferManagement;
 404     if(bufman)
 405     {
 406       Forbid();
 407       AbortRW(ncp, bufman, deverror(IOERR_ABORTED, S2WERR_GENERIC_ERROR));
 408       AbortList(ncp, &ncp->ncp_EventList, bufman, deverror(IOERR_ABORTED, S2WERR_GENERIC_ERROR));
 409       Permit();
 410     }
 411
 412     /* Return success */
 413     return RC_OK;
 414 }
 415
 416
 417 /*
 418  *======================================================================
 419  * cmdDeviceQuery(ioreq, base)
 420  *======================================================================
 421  *
 422  * This is the device S2_DEVICEQUERY routine.
 423  *
 424  * This routine return various parameters for this network interface.
 425  *
 426  */
 427
 428 static
 429 const struct Sana2DeviceQuery DeviceQueryBlock[] =
 430 {
 431     {
 432         sizeof(struct Sana2DeviceQuery), sizeof(struct Sana2DeviceQuery),
 433         0, 0,
 434         ETHER_ADDR_SIZE * 8,
 435         ETHERPKT_SIZE,
 436         10000000,
 437         S2WireType_Ethernet
 438     }
 439 };
 440
 441
 442 WORD cmdDeviceQuery(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 443 {
 444     struct Sana2DeviceQuery *query;
 445
 446     KPRINTF(1, ("S2_DEVICEQUERY ioreq: 0x%08lx\n", ioreq));
 447
 448     /* NULL ptr? */
 449     query = (struct Sana2DeviceQuery *) ioreq->ios2_StatData;
 450     if(!query)
 451     {
 452         return deverror(S2ERR_BAD_ARGUMENT, S2WERR_NULL_POINTER);
 453     }
 454
 455     /* Enough space to store the info ? */
 456     if(query->SizeAvailable < sizeof(struct Sana2DeviceQuery))
 457     {
 458         KPRINTF(1, ("S2_DEVICEQUERY: too small buffer supplied! (%lu / %lu)\n",
 459                     query->SizeAvailable, sizeof(struct Sana2DeviceQuery)));
 460
 461         query->SizeSupplied = 0;
 462         return deverror(S2ERR_BAD_ARGUMENT, S2WERR_BAD_STATDATA);
 463     }
 464
 465     CopyMem(&((struct Sana2DeviceQuery *) DeviceQueryBlock)->SizeSupplied, &query->SizeSupplied, sizeof(struct Sana2DeviceQuery) - sizeof(ULONG));
 466
 467     /* Return success */
 468     return RC_OK;
 469 }
 470
 471 /*
 472  *======================================================================
 473  * cmdGetStationAddress(ioreq, base)
 474  *======================================================================
 475  *
 476  * This is the device S2_GETSTATIONADDRESS routine.
 477  *
 478  * This routine return current and default interface hardware addresses.
 479  *
 480  */
 481
 482 WORD cmdGetStationAddress(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 483 {
 484     UWORD cnt;
 485
 486     KPRINTF(1, ("S2_GETSTATIONADDRESS ioreq: 0x%08lx\n", ioreq));
 487
 488     /* Source address = current station address
 489        Dest address = default station address
 490     */
 491     for(cnt = 0; cnt < ETHER_ADDR_SIZE; cnt++)
 492     {
 493         ioreq->ios2_SrcAddr[cnt] = ncp->ncp_MacAddress[cnt];
 494         ioreq->ios2_DstAddr[cnt] = ncp->ncp_ROMAddress[cnt];
 495     }
 496
 497     /* Clear the rest */
 498     for(; cnt < SANA2_MAX_ADDR_BYTES; cnt++)
 499     {
 500       ioreq->ios2_SrcAddr[cnt] = 0;
 501       ioreq->ios2_DstAddr[cnt] = 0;
 502     }
 503
 504     /* Return success */
 505     return(RC_OK);
 506 }
 507
 508 WORD cmdConfigInterface(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 509 {
 510 #if 0
 511     UWORD cnt;
 512 #endif
 513
 514     KPRINTF(1, ("S2_CONFIGINTERFACE ioreq: 0x%08lx\n", ioreq));
 515
 516     /* This stuff must be atomic */
 517     Forbid();
 518 #if 0
 519     if(ncp->ncp_StateFlags & DDF_CONFIGURED)
 520     {
 521         Permit();
 522         /* Error, already configured */
 523         return deverror(S2ERR_BAD_STATE, S2WERR_IS_CONFIGURED);
 524     }
 525
 526     /* Check for valid address */
 527     if(*((LONG *) ioreq->ios2_SrcAddr) <= 0)
 528     {
 529         Permit();
 530         return deverror(S2ERR_BAD_ADDRESS, S2WERR_SRC_ADDRESS);
 531     }
 532
 533     /* Copy the address */
 534     for(cnt = 0; cnt < ETHER_ADDR_SIZE; cnt++)
 535     {
 536         ncp->ncp_MacAddress[cnt] = ioreq->ios2_SrcAddr[cnt];
 537     }
 538 #endif
 539     ncp->ncp_StateFlags |= DDF_CONFIGURED;
 540     if(ncp->ncp_Unit.unit_MsgPort.mp_SigTask)
 541     {
 542         Signal(ncp->ncp_Unit.unit_MsgPort.mp_SigTask, 1L<<(ncp->ncp_Unit.unit_MsgPort.mp_SigBit));
 543     }
 544     Permit();
 545         KPRINTF(1, ("S2_CONFIGINTERFACE ok/n"));
 546
 547     return(RC_OK);
 548 }
 549
 550 WORD cmdAddMulticastAddress(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 551
 552 {
 553     KPRINTF(1, ("S2_ADDMULTICASTADDRESS 0x%08lx%04lx\n",
 554                 ((ULONG *) ioreq->ios2_SrcAddr)[0], ((UWORD *) ioreq->ios2_SrcAddr)[2]));
 555
 556     return AddMCastRange(ncp, ioreq, ioreq->ios2_SrcAddr, ioreq->ios2_SrcAddr);
 557 }
 558
 559 WORD cmdDelMulticastAddress(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 560 {
 561     KPRINTF(1, ("S2_DELMULTICASTADDRESS 0x%08lx%04lx\n",
 562                 ((ULONG *) ioreq->ios2_SrcAddr)[0], ((UWORD *) ioreq->ios2_SrcAddr)[2]));
 563
 564     return DelMCastRange(ncp, ioreq, ioreq->ios2_SrcAddr, ioreq->ios2_SrcAddr);
 565 }
 566
 567 WORD cmdAddMulticastAddresses(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 568 {
 569     KPRINTF(1, ("S2_ADDMULTICASTADDRESSES 0x%08lx%04lx - 0x%08lx%04lx\n",
 570                 ((ULONG *) ioreq->ios2_SrcAddr)[0], ((UWORD *) ioreq->ios2_SrcAddr)[2],
 571                 ((ULONG *) ioreq->ios2_DstAddr)[0], ((UWORD *) ioreq->ios2_DstAddr)[2]));
 572
 573     return AddMCastRange(ncp, ioreq, ioreq->ios2_SrcAddr, ioreq->ios2_DstAddr);
 574 }
 575
 576 WORD cmdDelMulticastAddresses(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 577 {
 578     KPRINTF(1, ("S2_DELMULTICASTADDRESSES 0x%08lx%04lx - 0x%08lx%04lx\n",
 579                 ((ULONG *) ioreq->ios2_SrcAddr)[0], ((UWORD *) ioreq->ios2_SrcAddr)[2],
 580                 ((ULONG *) ioreq->ios2_DstAddr)[0], ((UWORD *) ioreq->ios2_DstAddr)[2]));
 581
 582     return DelMCastRange(ncp, ioreq, ioreq->ios2_SrcAddr, ioreq->ios2_DstAddr);
 583 }
 584
 585 #define mcmp(a,b) (memcmp(a,b,ETHER_ADDR_SIZE)==0)
 586
 587 WORD AddMCastRange(struct NepClassEth *ncp, struct IOSana2Req *ioreq, UBYTE *lower, UBYTE *upper)
 588 {
 589     struct MulticastAddressRange *mar;
 590     WORD cnt;
 591
 592     /* Valid multicast addresses? */
 593     if(((lower[0] & 1) == 0) || ((upper[0] & 1) == 0))
 594     {
 595         return deverror(S2ERR_BAD_ADDRESS, S2WERR_BAD_MULTICAST);
 596     }
 597
 598     /* Lock access to list */
 599     Forbid();
 600
 601     /* Find matching node */
 602     mar = (struct MulticastAddressRange *) ncp->ncp_Multicasts.lh_Head;
 603     while(mar->mar_Node.ln_Succ)
 604     {
 605         if(mcmp(lower, mar->mar_LowerAddr) &&
 606            mcmp(upper, mar->mar_UpperAddr))
 607         {
 608             break;
 609         }
 610         mar = (struct MulticastAddressRange *) mar->mar_Node.ln_Succ;
 611     }
 612
 613     if(!mar->mar_Node.ln_Succ)
 614     {
 615         /* Add new node */
 616         mar = AllocVec(sizeof(struct MulticastAddressRange), MEMF_CLEAR|MEMF_PUBLIC);
 617         if(!mar)
 618         {
 619             Permit();
 620             return deverror(S2ERR_NO_RESOURCES, S2WERR_GENERIC_ERROR);
 621         }
 622         for(cnt = 0; cnt < ETHER_ADDR_SIZE; cnt++)
 623         {
 624             mar->mar_LowerAddr[cnt] = *lower++;
 625             mar->mar_UpperAddr[cnt] = *upper++;
 626         }
 627         mar->mar_UseCount = 1;
 628         AddTail(&ncp->ncp_Multicasts, (struct Node *) mar);
 629
 630         Permit();
 631
 632         return RC_OK;
 633     }
 634     mar->mar_UseCount++;
 635     Permit();
 636
 637     /* Return success */
 638     return RC_OK;
 639 }
 640
 641 WORD DelMCastRange(struct NepClassEth *ncp, struct IOSana2Req *ioreq, UBYTE *lower, UBYTE *upper)
 642 {
 643     struct MulticastAddressRange *mar;
 644
 645     /* Lock access to list */
 646     Forbid();
 647
 648     /* Find matching node */
 649     mar = (struct MulticastAddressRange *) ncp->ncp_Multicasts.lh_Head;
 650     while(mar->mar_Node.ln_Succ)
 651     {
 652         if(mcmp(lower, mar->mar_LowerAddr) &&
 653            mcmp(upper, mar->mar_UpperAddr))
 654         {
 655             if(!--mar->mar_UseCount)
 656             {
 657                 Remove((struct Node *) mar);
 658                 Permit();
 659                 FreeVec(mar);
 660
 661                 return RC_OK;
 662             }
 663             Permit();
 664             return RC_OK;
 665         }
 666         mar = (struct MulticastAddressRange *) mar->mar_Node.ln_Succ;
 667     }
 668     Permit();
 669
 670     /* Return with failure */
 671     return deverror(S2ERR_BAD_STATE, S2WERR_BAD_MULTICAST);
 672 }
 673
 674 WORD cmdMulticast(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 675 {
 676     KPRINTF(1, ("S2_MULTICAST ioreq: 0x%08lx to: 0x%08lx%04lx\n",
 677                 ioreq,
 678                 ((ULONG *) ioreq->ios2_DstAddr)[0], ((UWORD *) ioreq->ios2_DstAddr)[2]));
 679
 680     /* Is dest a multicast address? */
 681     if(ioreq->ios2_DstAddr[0] & 1)
 682     {
 683         return cmdWrite(ncp, ioreq);
 684     }
 685
 686     /* Trigger any tx or generic error events */
 687     nDoEvent(ncp, S2EVENT_ERROR|S2EVENT_TX);
 688
 689     /* Wasn't a multicast addr */
 690     return deverror(S2ERR_BAD_ADDRESS, S2WERR_BAD_MULTICAST);
 691 }
 692
 693 WORD cmdBroadcast(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 694 {
 695     UWORD cnt;
 696     KPRINTF(1, ("S2_BROADCAST ioreq: 0x%08lx\n", ioreq));
 697
 698     /* Dest address = broadcast */
 699     for(cnt = 0; cnt < ETHER_ADDR_SIZE; cnt++)
 700     {
 701         ioreq->ios2_DstAddr[cnt] = 0xff;
 702     }
 703     return cmdWrite(ncp, ioreq);
 704 }
 705
 706
 707 WORD cmdTrackType(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 708 {
 709     struct PacketTypeStats *pts;
 710
 711     KPRINTF(1, ("S2_TRACKTYPE ioreq: 0x%08lx type: %lu\n",
 712                 ioreq, ioreq->ios2_PacketType));
 713
 714     Forbid();
 715     /* Find matching node */
 716     pts = (struct PacketTypeStats *) ncp->ncp_TrackList.lh_Head;
 717     while(pts->pts_Node.ln_Succ)
 718     {
 719         /* Our packet type? */
 720         if(pts->pts_PacketType == ioreq->ios2_PacketType)
 721         {
 722             Permit();
 723             return deverror(S2ERR_BAD_STATE, S2WERR_ALREADY_TRACKED);
 724         }
 725         pts = (struct PacketTypeStats *) pts->pts_Node.ln_Succ;
 726     }
 727
 728     /* Alloc tracking node */
 729     pts = (struct PacketTypeStats *) AllocVec(sizeof(struct PacketTypeStats), MEMF_CLEAR|MEMF_PUBLIC);
 730     if(!pts)
 731     {
 732         return deverror(S2ERR_NO_RESOURCES, S2WERR_NOT_TRACKED);
 733     }
 734     /* Set up tracking node */
 735     pts->pts_PacketType = ioreq->ios2_PacketType;
 736
 737     /* Add the new node to tracklist */
 738     AddTail((struct List *) &ncp->ncp_TrackList, (struct Node *) pts);
 739     // caching
 740     if(pts->pts_PacketType == 2048)
 741     {
 742         ncp->ncp_TypeStats2048 = &pts->pts_Stats;
 743     }
 744     else if(pts->pts_PacketType == 2054)
 745     {
 746         ncp->ncp_TypeStats2054 = &pts->pts_Stats;
 747     }
 748     Permit();
 749
 750     /* Return success */
 751     return RC_OK;
 752 }
 753
 754
 755 WORD cmdUntrackType(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 756 {
 757     struct PacketTypeStats *pts;
 758     KPRINTF(1, ("S2_UNTRACKTYPE ioreq: 0x%08lx type: %lu\n",
 759                 ioreq, ioreq->ios2_PacketType));
 760
 761     Forbid();
 762     /* Find matching node */
 763     pts = (struct PacketTypeStats *) ncp->ncp_TrackList.lh_Head;
 764     while(pts->pts_Node.ln_Succ)
 765     {
 766         /* Our packet type? */
 767         if(pts->pts_PacketType == ioreq->ios2_PacketType)
 768         {
 769             Remove(&pts->pts_Node);
 770             // caching
 771             if(pts->pts_PacketType == 2048)
 772             {
 773                 ncp->ncp_TypeStats2048 = NULL;
 774             }
 775             else if(pts->pts_PacketType == 2054)
 776             {
 777                 ncp->ncp_TypeStats2054 = NULL;
 778             }
 779             Permit();
 780             FreeVec(pts);
 781             return RC_OK;
 782
 783         }
 784         pts = (struct PacketTypeStats *) pts->pts_Node.ln_Succ;
 785     }
 786     Permit();
 787     /* Return failure */
 788     return deverror(S2ERR_BAD_STATE, S2WERR_NOT_TRACKED);
 789 }
 790
 791
 792 WORD cmdGetTypeStats(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 793 {
 794     struct Sana2PacketTypeStats *tostats;
 795     struct Sana2PacketTypeStats *fromstats;
 796
 797     KPRINTF(1, ("S2_GETTYPESTATS ioreq: 0x%08lx type: %lu\n",
 798                 ioreq, ioreq->ios2_PacketType));
 799
 800     /* NULL ptr? */
 801     tostats = (struct Sana2PacketTypeStats *) ioreq->ios2_StatData;
 802     if(!tostats)
 803     {
 804         return deverror(S2ERR_BAD_ARGUMENT, S2WERR_NULL_POINTER);
 805     }
 806
 807     Forbid();
 808     fromstats = FindPacketTypeStats(ncp, ioreq->ios2_PacketType);
 809     if(fromstats)
 810     {
 811         /* Copy the stats */
 812         CopyMem(fromstats, tostats, sizeof(struct Sana2PacketTypeStats));
 813         Permit();
 814
 815         /* Return success */
 816         return RC_OK;
 817     }
 818     Permit();
 819
 820     /* Return error */
 821     return deverror(S2ERR_BAD_STATE, S2WERR_NOT_TRACKED);
 822 }
 823
 824
 825 WORD cmdGetSpecialStats(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 826 {
 827     struct Sana2SpecialStatHeader *stats;
 828     struct Sana2SpecialStatRecord *record;
 829     ULONG maxcount;
 830
 831     KPRINTF(1, ("S2_GETSPECIALSTATS ioreq: 0x%08lx\n", ioreq));
 832
 833     /* NULL ptr? */
 834     stats = (struct Sana2SpecialStatHeader *) ioreq->ios2_StatData;
 835     if(!stats)
 836     {
 837         return deverror(S2ERR_BAD_ARGUMENT, S2WERR_NULL_POINTER);
 838     }
 839
 840     stats->RecordCountSupplied = 0;
 841     maxcount = stats->RecordCountMax;
 842     record = (struct Sana2SpecialStatRecord *) (stats + 1);
 843
 844     if(maxcount--)
 845     {
 846         stats->RecordCountSupplied++;
 847
 848         record->Type   = S2SS_ETHERNET_BADMULTICAST;
 849         record->Count  = ncp->ncp_BadMulticasts;
 850         record->String = "bad multicasts";
 851         record++;
 852
 853         if(maxcount--)
 854         {
 855             stats->RecordCountSupplied++;
 856
 857             record->Type   = S2SS_ETHERNET_RETRIES;
 858             record->Count  = ncp->ncp_Retries;
 859             record->String = "retries";
 860             //record++;
 861         }
 862     }
 863
 864     /* Return success */
 865     return RC_OK;
 866 }
 867
 868
 869 WORD cmdGetGlobalStats(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 870 {
 871     struct Sana2DeviceStats *stats;
 872
 873     KPRINTF(1, ("S2_GETGLOBALSTATS ioreq: 0x%08lx\n", ioreq));
 874
 875     /* NULL ptr? */
 876     stats = (struct Sana2DeviceStats *) ioreq->ios2_StatData;
 877     if(!stats)
 878     {
 879         return deverror(S2ERR_BAD_ARGUMENT, S2WERR_NULL_POINTER);
 880     }
 881
 882     CopyMem(&ncp->ncp_DeviceStats, stats, sizeof(struct Sana2DeviceStats));
 883
 884     /* Return success */
 885     return RC_OK;
 886 }
 887
 888
 889 #define KNOWN_EVENTS (S2EVENT_ERROR |   \
 890                       S2EVENT_TX |      \
 891                       S2EVENT_RX |      \
 892                       S2EVENT_ONLINE |  \
 893                       S2EVENT_OFFLINE | \
 894                       S2EVENT_BUFF |    \
 895                       S2EVENT_HARDWARE)
 896
 897 WORD cmdOnEvent(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 898 {
 899     KPRINTF(1, ("S2_ONEVENT ioreq: 0x%08lx mask: 0x%08lx\n", ioreq,
 900                 ioreq->ios2_WireError));
 901
 902     /* Do we know the requested events? */
 903     if(ioreq->ios2_WireError & (~KNOWN_EVENTS))
 904     {
 905         return deverror(S2ERR_NOT_SUPPORTED, S2WERR_BAD_EVENT);
 906     }
 907
 908     /* If online return S2EVENT_ONLINE immediately
 909        If offline return S2EVENT_OFFLINE immediately. */
 910     if(ncp->ncp_StateFlags & DDF_ONLINE)
 911     {
 912         if(ioreq->ios2_WireError & S2EVENT_ONLINE)
 913         {
 914             ioreq->ios2_WireError = S2EVENT_ONLINE;
 915
 916             /* Return success */
 917             return RC_OK;
 918         }
 919     } else {
 920         if(ioreq->ios2_WireError & S2EVENT_OFFLINE)
 921         {
 922             ioreq->ios2_WireError = S2EVENT_OFFLINE;
 923
 924             /* Return success */
 925             return RC_OK;
 926         }
 927     }
 928
 929     /* Must be queued */
 930     ioreq->ios2_Req.io_Flags &= ~IOF_QUICK;
 931
 932     /* Queue the ioreq */
 933     Forbid();
 934     AddTail((struct List *) &ncp->ncp_EventList, (struct Node *) ioreq);
 935     Permit();
 936
 937     /* Don't reply the ioreq, it's pending */
 938     return RC_DONTREPLY;
 939 }
 940
 941
 942 WORD cmdReadOrphan(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 943 {
 944     struct BufMan *bufman;
 945
 946     KPRINTF(1, ("S2_READORPHAN ioreq: 0x%08lx type: %lu\n", ioreq,
 947                 ioreq->ios2_PacketType));
 948
 949     /* Configured? */
 950     if(!(ncp->ncp_StateFlags & DDF_CONFIGURED))
 951     {
 952         return deverror(S2ERR_BAD_STATE, S2WERR_NOT_CONFIGURED);
 953     }
 954
 955     /* Online? */
 956     if(!(ncp->ncp_StateFlags & DDF_ONLINE))
 957     {
 958         return deverror(S2ERR_OUTOFSERVICE, S2WERR_UNIT_OFFLINE);
 959     }
 960
 961     /* Valid bufman? got copytobuf routine? */
 962     bufman = ioreq->ios2_BufferManagement;
 963     if((!bufman) || (!bufman->bm_CopyToBuf))
 964     {
 965         return deverror(S2ERR_BAD_ARGUMENT, S2WERR_NULL_POINTER);
 966     }
 967
 968     /* Must be queued */
 969     ioreq->ios2_Req.io_Flags &= ~IOF_QUICK;
 970
 971     /* Queue the ioreq */
 972     Forbid();
 973     AddTail((struct List *) &ncp->ncp_OrphanQueue, (struct Node *) ioreq);
 974     Permit();
 975
 976     /* Don't reply the ioreq, it's pending */
 977     return RC_DONTREPLY;
 978 }
 979
 980
 981 WORD cmdOnline(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
 982 {
 983     KPRINTF(1, ("S2_ONLINE ioreq: 0x%08lx\n", ioreq));
 984
 985     Forbid();
 986     /* Already online? */
 987     if(!(ncp->ncp_StateFlags & DDF_ONLINE))
 988     {
 989         /* Configured? */
 990         if(!(ncp->ncp_StateFlags & DDF_CONFIGURED))
 991         {
 992             Permit();
 993             return deverror(S2ERR_BAD_STATE, S2WERR_NOT_CONFIGURED);
 994         }
 995
 996         /* Mark no longer offline */
 997         ncp->ncp_StateFlags &= ~DDF_OFFLINE;
 998
 999         /* Mark being online */
1000         ncp->ncp_StateFlags |= DDF_ONLINE;
1001         if(ncp->ncp_Unit.unit_MsgPort.mp_SigTask)
1002         {
1003             Signal(ncp->ncp_Unit.unit_MsgPort.mp_SigTask, 1L<<(ncp->ncp_Unit.unit_MsgPort.mp_SigBit));
1004         }
1005         Permit();
1006
1007         /* Trigger any ONLINE events */
1008         nDoEvent(ncp, S2EVENT_ONLINE);
1009
1010         return RC_OK;
1011     }
1012
1013     Permit();
1014     /* Return success */
1015     return RC_OK;
1016 }
1017
1018
1019 WORD cmdOffline(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
1020
1021 {
1022     KPRINTF(1, ("S2_OFFLINE ioreq: 0x%08lx\n", ioreq));
1023
1024     Forbid();
1025     /* Mark being offline */
1026     ncp->ncp_StateFlags |= DDF_OFFLINE;
1027
1028     /* Already offline? */
1029     if(ncp->ncp_StateFlags & DDF_ONLINE)
1030     {
1031         /* Mark no longer online */
1032         ncp->ncp_StateFlags &= ~DDF_ONLINE;
1033         if(ncp->ncp_Unit.unit_MsgPort.mp_SigTask)
1034         {
1035             Signal(ncp->ncp_Unit.unit_MsgPort.mp_SigTask, 1L<<(ncp->ncp_Unit.unit_MsgPort.mp_SigBit));
1036         }
1037         Permit();
1038
1039         /* *DO NOT* abort pending read & write requests.
1040            Miami dies a horrible death if this is enabled!
1041         */
1042         if(ioreq->ios2_BufferManagement)
1043         {
1044             AbortRW(ncp, ioreq->ios2_BufferManagement, deverror(S2ERR_OUTOFSERVICE, S2WERR_UNIT_OFFLINE));
1045         }
1046
1047         /* Trigger any OFFLINE events */
1048         nDoEvent(ncp, S2EVENT_OFFLINE);
1049
1050         /* Don't reply the ioreq, it's pending */
1051         return RC_OK;
1052     }
1053     Permit();
1054
1055     /* Return success */
1056     return RC_OK;
1057 }
1058
1059
1060 AROS_LH1(void, devBeginIO,
1061          AROS_LHA(struct IOSana2Req *, ioreq, A1),
1062          DEVBASETYPEPTR, base, 5, dev)
1063 {
1064     AROS_LIBFUNC_INIT
1065
1066     struct NepClassEth *ncp = (struct NepClassEth *) ioreq->ios2_Req.io_Unit;
1067     WORD ret = IOERR_NOCMD;
1068
1069     KPRINTF(1, ("devBeginIO ioreq: 0x%08lx base: 0x%08lx cmd: %lu\n", ioreq, base, ioreq->ios2_Req.io_Command));
1070
1071     ioreq->ios2_Req.io_Message.mn_Node.ln_Type = NT_MESSAGE;
1072     ioreq->ios2_Req.io_Error                   = 0;
1073
1074     if(ioreq->ios2_Req.io_Command < NSCMD_DEVICEQUERY)
1075     {
1076         switch(ioreq->ios2_Req.io_Command)
1077         {
1078             case CMD_READ:
1079                 ret = cmdRead(ncp, ioreq);
1080                 break;
1081
1082             case CMD_FLUSH:
1083                 ret = cmdFlush(ncp, ioreq);
1084                 break;
1085
1086             case CMD_WRITE:
1087                 ret = cmdWrite(ncp, ioreq);
1088                 break;
1089
1090             case S2_GETSTATIONADDRESS:
1091                 ret = cmdGetStationAddress(ncp, ioreq);
1092                 break;
1093
1094             case S2_DEVICEQUERY:
1095                 ret = cmdDeviceQuery(ncp, ioreq);
1096                 break;
1097
1098             case S2_CONFIGINTERFACE:
1099                 ret = cmdConfigInterface(ncp, ioreq);
1100                 break;
1101
1102             case S2_ADDMULTICASTADDRESS:
1103                 ret = cmdAddMulticastAddress(ncp, ioreq);
1104                 break;
1105
1106             case S2_DELMULTICASTADDRESS:
1107                 ret = cmdDelMulticastAddress(ncp, ioreq);
1108                 break;
1109
1110             case S2_MULTICAST:
1111                 ret = cmdMulticast(ncp, ioreq);
1112                 break;
1113
1114             case S2_BROADCAST:
1115                 ret = cmdBroadcast(ncp, ioreq);
1116                 break;
1117
1118             case S2_TRACKTYPE:
1119                 ret = cmdTrackType(ncp, ioreq);
1120                 break;
1121
1122             case S2_UNTRACKTYPE:
1123                 ret = cmdUntrackType(ncp, ioreq);
1124                 break;
1125
1126             case S2_GETTYPESTATS:
1127                 ret = cmdGetTypeStats(ncp, ioreq);
1128                 break;
1129
1130             case S2_GETSPECIALSTATS:
1131                 ret = cmdGetSpecialStats(ncp, ioreq);
1132                 break;
1133
1134             case S2_GETGLOBALSTATS:
1135                 ret = cmdGetGlobalStats(ncp, ioreq);
1136                 break;
1137
1138             case S2_ONEVENT:
1139                 ret = cmdOnEvent(ncp, ioreq);
1140                 break;
1141
1142             case S2_READORPHAN:
1143                 ret = cmdReadOrphan(ncp, ioreq);
1144                 break;
1145
1146             case S2_ONLINE:
1147                 ret = cmdOnline(ncp, ioreq);
1148                 break;
1149
1150             case S2_OFFLINE:
1151                 ret = cmdOffline(ncp, ioreq);
1152                 break;
1153
1154             default:
1155                 ret = IOERR_NOCMD;
1156                 break;
1157         }
1158     } else {
1159         switch(ioreq->ios2_Req.io_Command)
1160         {
1161             case NSCMD_DEVICEQUERY:
1162                 ret = cmdNSDeviceQuery(ncp, (struct IOStdReq *) ioreq);
1163                 break;
1164
1165             case S2_ADDMULTICASTADDRESSES:
1166                 ret = cmdAddMulticastAddresses(ncp, ioreq);
1167                 break;
1168
1169             case S2_DELMULTICASTADDRESSES:
1170                 ret = cmdDelMulticastAddresses(ncp, ioreq);
1171                 break;
1172
1173             default:
1174                 ret = IOERR_NOCMD;
1175                 break;
1176         }
1177     }
1178
1179     if(ret != RC_DONTREPLY)
1180     {
1181         KPRINTF(1, ("TermIO\n"));
1182         if (ret != RC_OK)
1183         {
1184             /* Set error codes */
1185             ioreq->ios2_Req.io_Error = ret & 0xff;
1186         }
1187         /* Terminate the iorequest */
1188         TermIO(ncp, ioreq);
1189     }
1190
1191     AROS_LIBFUNC_EXIT
1192 }
1193
1194 AROS_LH1(LONG, devAbortIO,
1195          AROS_LHA(struct IOSana2Req *, ioreq, A1),
1196          DEVBASETYPEPTR, base, 6, dev)
1197 {
1198     AROS_LIBFUNC_INIT
1199
1200     struct NepClassEth *ncp = (struct NepClassEth *) ioreq->ios2_Req.io_Unit;
1201     struct BufMan *worknode, *nextnode;
1202
1203     KPRINTF(5, ("devAbortIO ioreq: 0x%08lx\n", ioreq));
1204
1205     /* Is it pending? */
1206     Forbid();
1207     if(ioreq->ios2_Req.io_Message.mn_Node.ln_Type == NT_MESSAGE)
1208     {
1209
1210         switch (ioreq->ios2_Req.io_Command)
1211         {
1212             case CMD_READ:
1213                 /* Check all nodes in dd_bufmanlist until we succeed to abort or run out of nodes. */
1214                 worknode = (struct BufMan *) ncp->ncp_BufManList.lh_Head;
1215                 while((nextnode = (struct BufMan *) (((struct Node *) worknode)->ln_Succ)))
1216                 {
1217                     if(AbortReq(ncp, &worknode->bm_RXQueue, ioreq) == S2ERR_NO_ERROR)
1218                     {
1219                         /* Success, break out */
1220                         break;
1221                     }
1222                     worknode = nextnode;
1223                 }
1224                 break;
1225
1226             case S2_READORPHAN:
1227                 AbortReq(ncp, &ncp->ncp_OrphanQueue, ioreq);
1228                 break;
1229
1230             case CMD_WRITE:
1231             case S2_MULTICAST:
1232             case S2_BROADCAST:
1233                 AbortReq(ncp, &ncp->ncp_WriteQueue, ioreq);
1234                 break;
1235
1236             // these commands may dispatch their ioreq to the USB task; catch from the message port
1237             case S2_ONLINE:
1238             case S2_OFFLINE:
1239             case S2_CONFIGINTERFACE:
1240             case S2_ADDMULTICASTADDRESS:
1241             case S2_DELMULTICASTADDRESS:
1242             case S2_ADDMULTICASTADDRESSES:
1243             case S2_DELMULTICASTADDRESSES:
1244                 AbortReq(ncp, &ncp->ncp_Unit.unit_MsgPort.mp_MsgList, ioreq);
1245                 break;
1246
1247             case S2_ONEVENT:
1248                 AbortReq(ncp, &ncp->ncp_EventList, ioreq);
1249                 break;
1250
1251             default:
1252                 KPRINTF(1, ("devAbortIO: not READ, READORPHAN, WRITE, MULTICAST, BROADCAST or ONEVENT\n"));
1253                 break;
1254         }
1255     }
1256     Permit();
1257     return(-1);
1258
1259     AROS_LIBFUNC_EXIT
1260 }
1261
1262 /* NSD stuff
1263 */
1264
1265 static
1266 const UWORD NSDSupported[] =
1267 {
1268     CMD_FLUSH, CMD_READ, CMD_WRITE,
1269     S2_DEVICEQUERY,
1270     S2_GETSTATIONADDRESS,
1271     S2_CONFIGINTERFACE,
1272     S2_ADDMULTICASTADDRESS, S2_DELMULTICASTADDRESS,
1273     S2_MULTICAST, S2_BROADCAST,
1274     S2_TRACKTYPE, S2_UNTRACKTYPE,
1275     S2_GETTYPESTATS, S2_GETSPECIALSTATS, S2_GETGLOBALSTATS,
1276     S2_ONEVENT,
1277     S2_READORPHAN,
1278     S2_ONLINE, S2_OFFLINE,
1279     NSCMD_DEVICEQUERY,
1280     S2_ADDMULTICASTADDRESSES, S2_DELMULTICASTADDRESSES,
1281     0
1282 };
1283
1284 WORD cmdNSDeviceQuery(struct NepClassEth *ncp, struct IOStdReq *ioreq)
1285 {
1286     struct my_NSDeviceQueryResult *query;
1287
1288     query = (struct my_NSDeviceQueryResult *) ioreq->io_Data;
1289
1290     KPRINTF(10, ("NSCMD_DEVICEQUERY ioreq: 0x%08lx query: 0x%08lx\n", ioreq, query));
1291
1292     /* NULL ptr?
1293        Enough data?
1294        Valid request?
1295     */
1296     if((!query) ||
1297        (ioreq->io_Length < sizeof(struct my_NSDeviceQueryResult)) ||
1298        (query->DevQueryFormat != 0) ||
1299        (query->SizeAvailable != 0))
1300     {
1301         /* Return error. This is special handling, since iorequest is only
1302            guaranteed to be sizeof(struct IOStdReq). If we'd let our
1303            devBeginIO dispatcher return the error, it would trash some
1304            memory past end of the iorequest (ios2_WireError field).
1305          */
1306          ioreq->io_Error = IOERR_NOCMD;
1307          TermIO(ncp, (struct IOSana2Req *) ioreq);
1308
1309          /* Don't reply, we already did.
1310          */
1311          return RC_DONTREPLY;
1312     }
1313
1314     ioreq->io_Actual         = query->SizeAvailable
1315                              = sizeof(struct my_NSDeviceQueryResult);
1316     query->DeviceType        = NSDEVTYPE_SANA2;
1317     query->DeviceSubType     = 0;
1318     query->SupportedCommands = NSDSupported;
1319
1320     /* Return success (note that this will NOT poke ios2_WireError).
1321     */
1322     return RC_OK;
1323 }
1324
1325 /*
1326  *======================================================================
1327  * AbortReq(list, ioreq, base)
1328  *======================================================================
1329  *
1330  * Locate an IO request in a linked list and abort it if found.
1331  *
1332  */
1333
1334 LONG AbortReq(struct NepClassEth *ncp, struct List *list, struct IOSana2Req *ioreq)
1335 {
1336     struct Node *node;
1337
1338     for(node = list->lh_Head; node->ln_Succ; node = node->ln_Succ)
1339     {
1340         if(node == (struct Node *) ioreq)
1341         {
1342             //KPRINTF(1, ("AbortReq: aborted 0x%08lx\n", ioreq));
1343
1344             Remove(&ioreq->ios2_Req.io_Message.mn_Node);
1345             ioreq->ios2_Req.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
1346             ioreq->ios2_Req.io_Error = IOERR_ABORTED;
1347             ReplyMsg(&ioreq->ios2_Req.io_Message);
1348
1349             return S2ERR_NO_ERROR;
1350         }
1351     }
1352
1353     return S2ERR_BAD_STATE;
1354 }
1355
1356
1357
1358 /*
1359  *===========================================================
1360  * TermIO(ioreq, base)
1361  *===========================================================
1362  *
1363  * Return completed ioreq to sender.
1364  *
1365  */
1366
1367 void TermIO(struct NepClassEth *ncp, struct IOSana2Req *ioreq)
1368 {
1369     ioreq->ios2_Req.io_Message.mn_Node.ln_Type = NT_FREEMSG;
1370
1371     /* If not quick I/O, reply the message
1372     */
1373     if(!(ioreq->ios2_Req.io_Flags & IOF_QUICK))
1374     {
1375         ReplyMsg(&ioreq->ios2_Req.io_Message);
1376     }
1377 }
1378
1379 /*
1380  *======================================================================
1381  * AbortList(list, bufman, error, base)
1382  *======================================================================
1383  *
1384  * Aborts all pending ioreqs in given list with io_Error & ios2_WireError
1385  * set.
1386  *
1387  * error is deverror() macro packed error number.
1388  *
1389  */
1390
1391 void AbortList(struct NepClassEth *ncp, struct List *list, struct BufMan *bufman, WORD error)
1392 {
1393     struct IOSana2Req *ioreq, *nextioreq;
1394
1395     if(bufman)
1396     {
1397         for(ioreq = (struct IOSana2Req *) list->lh_Head;
1398             (nextioreq = (struct IOSana2Req *) ioreq->ios2_Req.io_Message.mn_Node.ln_Succ);
1399             ioreq = nextioreq)
1400         {
1401             if(ioreq->ios2_BufferManagement == bufman)
1402             {
1403                 Remove(&ioreq->ios2_Req.io_Message.mn_Node);
1404                 /*ioreq->ios2_Req.io_Message.mn_Node.ln_Type = NT_REPLYMSG;*/
1405                 ioreq->ios2_Req.io_Error = error & 0xff;
1406                 ioreq->ios2_WireError = error >> 8;
1407                 ReplyMsg(&ioreq->ios2_Req.io_Message);
1408             }
1409         }
1410     }
1411     else
1412     {
1413         while((ioreq = (struct IOSana2Req *) RemHead(list)))
1414         {
1415             /* ioreq->ios2_Req.io_Message.mn_Node.ln_Type = NT_REPLYMSG;*/
1416             ioreq->ios2_Req.io_Error = error & 0xff;
1417             ioreq->ios2_WireError = error >> 8;
1418             ReplyMsg(&ioreq->ios2_Req.io_Message);
1419         }
1420     }
1421 }
1422
1423
1424 /*
1425  *======================================================================
1426  * AbortRW(bufman, error, base)
1427  *======================================================================
1428  *
1429  * Aborts all pending reads and writes with io_Error & ios2_WireError
1430  * set.
1431  *
1432  * error is deverror() macro packed error number.
1433  *
1434  */
1435
1436 void AbortRW(struct NepClassEth *ncp, struct BufMan *bufman, WORD error)
1437 {
1438     AbortList(ncp, &bufman->bm_RXQueue, NULL, error);
1439     AbortList(ncp, &ncp->ncp_OrphanQueue, bufman, error);
1440     AbortList(ncp, &ncp->ncp_WriteQueue, bufman, error);
1441 }
1442
1443 struct Sana2PacketTypeStats * FindPacketTypeStats(struct NepClassEth *ncp, ULONG packettype)
1444 {
1445     struct PacketTypeStats *pts;
1446
1447     switch(packettype)
1448     {
1449         case 2048:
1450             return ncp->ncp_TypeStats2048;
1451             break;
1452
1453         case 2054:
1454             return ncp->ncp_TypeStats2054;
1455             break;
1456
1457         default:
1458             /* Find matching node - slowly */
1459             pts = (struct PacketTypeStats *) ncp->ncp_TrackList.lh_Head;
1460             while(pts->pts_Node.ln_Succ)
1461             {
1462                 /* Our packet type? */
1463                 if(pts->pts_PacketType == packettype)
1464                 {
1465                      return &pts->pts_Stats;
1466                 }
1467                 pts = (struct PacketTypeStats *) pts->pts_Node.ln_Succ;
1468             }
1469             break;
1470     }
1471
1472     return NULL;
1473 }
1474