workbench/devs/networks/etherlink3/device.c

   1 /*
   2
   3 Copyright (C) 2000-2006 Neil Cafferkey
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful, but
  11 WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13 General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18 MA 02111-1307, USA.
  19
  20 */
  21
  22
  23 #include <exec/types.h>
  24 #include <exec/resident.h>
  25 #include <exec/errors.h>
  26 #include <utility/utility.h>
  27 #include "initializers.h"
  28
  29 #include <proto/exec.h>
  30 /*#include <proto/alib.h>*/
  31 #include <clib/alib_protos.h>
  32 #include <proto/utility.h>
  33
  34 #include "device.h"
  35
  36 #include "device_protos.h"
  37 #include "pci_protos.h"
  38 #include "pccard_protos.h"
  39 #include "request_protos.h"
  40
  41
  42 /* Private prototypes */
  43
  44 static struct DevBase *DevInit(REG(d0, struct DevBase *dev_base),
  45    REG(a0, APTR seg_list), REG(BASE_REG, struct DevBase *base));
  46 static APTR DevExpunge(REG(BASE_REG, struct DevBase *base));
  47 static APTR DevReserved();
  48 static VOID DeleteDevice(struct DevBase *base);
  49
  50
  51 /* Return an error immediately if someone tries to run the device */
  52
  53 LONG Main()
  54 {
  55    return -1;
  56 }
  57
  58
  59 const TEXT device_name[] = DEVICE_NAME;
  60 const TEXT version_string[] =
  61    DEVICE_NAME " " STR(VERSION) "." STR(REVISION) " (" DATE ")\n";
  62 const TEXT utility_name[] = UTILITYNAME;
  63 static const TEXT prometheus_name[] = "prometheus.library";
  64 static const TEXT powerpci_name[] = "powerpci.library";
  65 const TEXT pccard_name[] = "pccard.library";
  66 const TEXT card_name[] = "card.resource";
  67 const TEXT timer_name[] = TIMERNAME;
  68
  69
  70 static const APTR vectors[] =
  71 {
  72    (APTR)DevOpen,
  73    (APTR)DevClose,
  74    (APTR)DevExpunge,
  75    (APTR)DevReserved,
  76    (APTR)DevBeginIO,
  77    (APTR)DevAbortIO,
  78    (APTR)-1
  79 };
  80
  81
  82 #ifdef __MORPHOS__
  83 #pragma pack(2)
  84 #endif
  85 static const struct
  86 {
  87    SMALLINITBYTEDEF(type);
  88    SMALLINITPINTDEF(name);
  89    SMALLINITBYTEDEF(flags);
  90    SMALLINITWORDDEF(version);
  91    SMALLINITWORDDEF(revision);
  92    SMALLINITPINTDEF(id_string);
  93    INITENDDEF;
  94 }
  95 init_data =
  96 {
  97    SMALLINITBYTE(OFFSET(Node, ln_Type), NT_DEVICE),
  98    SMALLINITPINT(OFFSET(Node, ln_Name), device_name),
  99    SMALLINITBYTE(OFFSET(Library, lib_Flags), LIBF_SUMUSED | LIBF_CHANGED),
 100    SMALLINITWORD(OFFSET(Library, lib_Version), VERSION),
 101    SMALLINITWORD(OFFSET(Library, lib_Revision), REVISION),
 102    SMALLINITPINT(OFFSET(Library, lib_IdString), version_string),
 103    INITEND
 104 };
 105 #ifdef __MORPHOS__
 106 #pragma pack()
 107 #endif
 108
 109
 110 static const APTR init_table[] =
 111 {
 112    (APTR)sizeof(struct DevBase),
 113    (APTR)vectors,
 114    (APTR)&init_data,
 115    (APTR)DevInit
 116 };
 117
 118
 119 const struct Resident rom_tag =
 120 {
 121    RTC_MATCHWORD,
 122    (struct Resident *)&rom_tag,
 123    (APTR)(&rom_tag + 1),
 124    RTF_AUTOINIT,
 125    VERSION,
 126    NT_DEVICE,
 127    0,
 128    (STRPTR)device_name,
 129    (STRPTR)version_string,
 130    (APTR)init_table
 131 };
 132
 133
 134 static const ULONG rx_tags[] =
 135 {
 136    S2_CopyToBuff,
 137    S2_CopyToBuff16,
 138 };
 139
 140
 141 static const ULONG tx_tags[] =
 142 {
 143    S2_CopyFromBuff,
 144    S2_CopyFromBuff16,
 145    S2_CopyFromBuff32
 146 };
 147
 148
 149
 150 /****i* etherlink3.device/DevInit ******************************************
 151 *
 152 *   NAME
 153 *       DevInit
 154 *
 155 *   SYNOPSIS
 156 *       dev_base = DevInit(dev_base, seg_list)
 157 *
 158 *       struct DevBase *DevInit(struct DevBase *, APTR);
 159 *
 160 ****************************************************************************
 161 *
 162 */
 163
 164 static struct DevBase *DevInit(REG(d0, struct DevBase *dev_base),
 165    REG(a0, APTR seg_list), REG(BASE_REG, struct DevBase *base))
 166 {
 167    BOOL success = TRUE;
 168
 169    /* Initialise base structure */
 170
 171    dev_base->sys_base = (APTR)base;
 172    base = dev_base;
 173    base->seg_list = seg_list;
 174    NewList((APTR)(&base->pci_units));
 175    NewList((APTR)(&base->isa_units));
 176    NewList((APTR)(&base->pccard_units));
 177
 178    /* Open libraries, resources and devices */
 179
 180    base->utility_base = (APTR)OpenLibrary(utility_name, UTILITY_VERSION);
 181    base->prometheus_base = OpenLibrary(prometheus_name, PROMETHEUS_VERSION);
 182    if(base->prometheus_base == NULL)
 183       base->powerpci_base = OpenLibrary(powerpci_name, POWERPCI_VERSION);
 184 #ifdef __MORPHOS__
 185    base->openpci_base = OpenLibrary(openpci_name, OPENPCI_VERSION);
 186 #endif
 187    base->pccard_base = OpenLibrary(pccard_name, PCCARD_VERSION);
 188    if(base->pccard_base != NULL)
 189       base->card_base = OpenResource(card_name);
 190
 191    if(base->utility_base == NULL || base->prometheus_base == NULL
 192       && base->powerpci_base == NULL && base->openpci_base == NULL
 193       && (base->pccard_base == NULL || base->card_base == NULL))
 194       success = FALSE;
 195
 196    if(OpenDevice(timer_name, UNIT_ECLOCK, (APTR)&base->timer_request, 0)
 197       != 0)
 198       success = FALSE;
 199
 200 #ifdef __MORPHOS__
 201    base->wrapper_int_code = (APTR)&int_trap;
 202 #endif
 203
 204    if(!success)
 205    {
 206       DeleteDevice(base);
 207       base = NULL;
 208    }
 209
 210    return base;
 211 }
 212
 213
 214
 215 /****i* etherlink3.device/DevOpen ******************************************
 216 *
 217 *   NAME
 218 *       DevOpen
 219 *
 220 *   SYNOPSIS
 221 *       error = DevOpen(request, unit_num, flags)
 222 *
 223 *       BYTE DevOpen(struct IOSana2Req *, ULONG, ULONG);
 224 *
 225 ****************************************************************************
 226 *
 227 */
 228
 229 BYTE DevOpen(REG(a1, struct IOSana2Req *request),
 230    REG(d0, ULONG unit_num), REG(d1, ULONG flags),
 231    REG(BASE_REG, struct DevBase *base))
 232 {
 233    struct DevUnit *unit;
 234    BYTE error = 0;
 235    struct Opener *opener;
 236    struct TagItem *tag_list;
 237    UWORD i;
 238
 239    base->device.dd_Library.lib_OpenCnt++;
 240    base->device.dd_Library.lib_Flags &= ~LIBF_DELEXP;
 241
 242    request->ios2_Req.io_Unit = NULL;
 243    tag_list = request->ios2_BufferManagement;
 244    request->ios2_BufferManagement = NULL;
 245
 246    /* Check request size */
 247
 248    if(request->ios2_Req.io_Message.mn_Length < sizeof(struct IOSana2Req))
 249       error = IOERR_OPENFAIL;
 250
 251    /* Get the requested unit */
 252
 253    if(error == 0)
 254    {
 255       request->ios2_Req.io_Unit = (APTR)(unit = GetUnit(unit_num, base));
 256       if(unit == NULL)
 257          error = IOERR_OPENFAIL;
 258    }
 259
 260    /* Handle device sharing */
 261
 262    if(error == 0)
 263    {
 264       if(unit->open_count != 0 && ((unit->flags & UNITF_SHARED) == 0
 265          || (flags & SANA2OPF_MINE) != 0))
 266          error = IOERR_UNITBUSY;
 267       unit->open_count++;
 268    }
 269
 270    if(error == 0)
 271    {
 272       if((flags & SANA2OPF_MINE) == 0)
 273          unit->flags |= UNITF_SHARED;
 274       else if((flags & SANA2OPF_PROM) != 0)
 275          unit->flags |= UNITF_PROM;
 276
 277       /* Set up buffer-management structure and get hooks */
 278
 279       request->ios2_BufferManagement = opener =
 280          AllocVec(sizeof(struct Opener), MEMF_PUBLIC | MEMF_CLEAR);
 281       if(opener == NULL)
 282          error = IOERR_OPENFAIL;
 283    }
 284
 285    if(error == 0)
 286    {
 287       NewList(&opener->read_port.mp_MsgList);
 288       opener->read_port.mp_Flags = PA_IGNORE;
 289       NewList((APTR)&opener->initial_stats);
 290
 291       for(i = 0; i < 2; i++)
 292          opener->rx_function = (APTR)GetTagData(rx_tags[i],
 293             (UPINT)opener->rx_function, tag_list);
 294       for(i = 0; i < 3; i++)
 295          opener->tx_function = (APTR)GetTagData(tx_tags[i],
 296             (UPINT)opener->tx_function, tag_list);
 297
 298       opener->filter_hook = (APTR)GetTagData(S2_PacketFilter, (UPINT)NULL,
 299          tag_list);
 300       opener->dma_tx_function =
 301          (APTR)GetTagData(S2_DMACopyFromBuff32, (UPINT)NULL, tag_list);
 302
 303       Disable();
 304       AddTail((APTR)&unit->openers, (APTR)opener);
 305       Enable();
 306    }
 307
 308    /* Back out if anything went wrong */
 309
 310    if(error != 0)
 311       CloseUnit(request, base);
 312
 313    /* Return */
 314
 315    request->ios2_Req.io_Error = error;
 316    return error;
 317 }
 318
 319
 320
 321 /****i* etherlink3.device/DevClose *****************************************
 322 *
 323 *   NAME
 324 *       DevClose
 325 *
 326 *   SYNOPSIS
 327 *       seg_list = DevClose(request)
 328 *
 329 *       APTR DevClose(struct IOSana2Req *);
 330 *
 331 ****************************************************************************
 332 *
 333 */
 334
 335 APTR DevClose(REG(a1, struct IOSana2Req *request),
 336    REG(BASE_REG, struct DevBase *base))
 337 {
 338    APTR seg_list = NULL;
 339
 340    /* Close the unit */
 341
 342    CloseUnit(request, base);
 343
 344    /* Expunge the device if a delayed expunge is pending */
 345
 346    if(base->device.dd_Library.lib_OpenCnt == 0)
 347    {
 348       if((base->device.dd_Library.lib_Flags & LIBF_DELEXP) != 0)
 349          seg_list = DevExpunge(base);
 350    }
 351
 352    return seg_list;
 353 }
 354
 355
 356
 357 /****i* etherlink3.device/DevExpunge ***************************************
 358 *
 359 *   NAME
 360 *       DevExpunge
 361 *
 362 *   SYNOPSIS
 363 *       seg_list = DevExpunge()
 364 *
 365 *       APTR DevExpunge(VOID);
 366 *
 367 ****************************************************************************
 368 *
 369 */
 370
 371 static APTR DevExpunge(REG(BASE_REG, struct DevBase *base))
 372 {
 373    APTR seg_list;
 374
 375    if(base->device.dd_Library.lib_OpenCnt == 0)
 376    {
 377       seg_list = base->seg_list;
 378       Remove((APTR)base);
 379       DeleteDevice(base);
 380    }
 381    else
 382    {
 383       base->device.dd_Library.lib_Flags |= LIBF_DELEXP;
 384       seg_list = NULL;
 385    }
 386
 387    return seg_list;
 388 }
 389
 390
 391
 392 /****i* etherlink3.device/DevReserved **************************************
 393 *
 394 *   NAME
 395 *       DevReserved
 396 *
 397 *   SYNOPSIS
 398 *       result = DevReserved()
 399 *
 400 *       APTR DevReserved(VOID);
 401 *
 402 ****************************************************************************
 403 *
 404 */
 405
 406 static APTR DevReserved()
 407 {
 408    return NULL;
 409 }
 410
 411
 412
 413 /****i* etherlink3.device/DevBeginIO ***************************************
 414 *
 415 *   NAME
 416 *       DevBeginIO
 417 *
 418 *   SYNOPSIS
 419 *       DevBeginIO(request)
 420 *
 421 *       VOID DevBeginIO(struct IORequest *);
 422 *
 423 ****************************************************************************
 424 *
 425 */
 426
 427 VOID DevBeginIO(REG(a1, struct IOSana2Req *request),
 428    REG(BASE_REG, struct DevBase *base))
 429 {
 430    struct DevUnit *unit;
 431
 432    request->ios2_Req.io_Error = 0;
 433    unit = (APTR)request->ios2_Req.io_Unit;
 434
 435    if(AttemptSemaphore(&unit->access_lock))
 436       ServiceRequest(request, base);
 437    else
 438       PutRequest(unit->request_ports[GENERAL_QUEUE], (APTR)request, base);
 439
 440    return;
 441 }
 442
 443
 444
 445 /****i* etherlink3.device/DevAbortIO ***************************************
 446 *
 447 *   NAME
 448 *       DevAbortIO -- Try to stop a request.
 449 *
 450 *   SYNOPSIS
 451 *       DevAbortIO(request)
 452 *
 453 *       VOID DevAbortIO(struct IOSana2Req *);
 454 *
 455 *   FUNCTION
 456 *       Do our best to halt the progress of a request.
 457 *
 458 ****************************************************************************
 459 *
 460 * Disable() used instead of a semaphore because device uses interrupts.
 461 *
 462 */
 463
 464 VOID DevAbortIO(REG(a1, struct IOSana2Req *request),
 465    REG(BASE_REG, struct DevBase *base))
 466 {
 467    struct DevUnit *unit;
 468
 469    unit = (APTR)request->ios2_Req.io_Unit;
 470
 471    Disable();
 472    if(request->ios2_Req.io_Message.mn_Node.ln_Type == NT_MESSAGE &&
 473       (request->ios2_Req.io_Flags & IOF_QUICK) == 0)
 474    {
 475       Remove((APTR)request);
 476       request->ios2_Req.io_Error = IOERR_ABORTED;
 477       request->ios2_WireError = S2WERR_GENERIC_ERROR;
 478       ReplyMsg((APTR)request);
 479    }
 480    Enable();
 481
 482    return;
 483 }
 484
 485
 486
 487 /****i* etherlink3.device/DeleteDevice *************************************
 488 *
 489 *   NAME
 490 *       DeleteDevice
 491 *
 492 *   SYNOPSIS
 493 *       DeleteDevice()
 494 *
 495 *       VOID DeleteDevice(VOID);
 496 *
 497 ****************************************************************************
 498 *
 499 */
 500
 501 VOID DeleteDevice(struct DevBase *base)
 502 {
 503    UWORD neg_size, pos_size;
 504
 505    /* Close devices */
 506
 507    CloseDevice((APTR)&base->timer_request);
 508
 509    /* Close libraries */
 510
 511    if(base->openpci_base != NULL)
 512       CloseLibrary(base->openpci_base);
 513    if(base->pccard_base != NULL)
 514       CloseLibrary(base->pccard_base);
 515    if(base->powerpci_base != NULL)
 516       CloseLibrary(base->powerpci_base);
 517    if(base->prometheus_base != NULL)
 518       CloseLibrary(base->prometheus_base);
 519    if(base->utility_base != NULL)
 520       CloseLibrary((APTR)base->utility_base);
 521
 522    /* Free device's memory */
 523
 524    neg_size = base->device.dd_Library.lib_NegSize;
 525    pos_size = base->device.dd_Library.lib_PosSize;
 526    FreeMem((UBYTE *)base - neg_size, pos_size + neg_size);
 527
 528    return;
 529 }
 530
 531
 532
 533 /****i* etherlink3.device/CloseUnit ****************************************
 534 *
 535 *   NAME
 536 *       CloseUnit
 537 *
 538 *   SYNOPSIS
 539 *       CloseUnit(request)
 540 *
 541 *       VOID CloseUnit(struct IOSana2Req *);
 542 *
 543 ****************************************************************************
 544 *
 545 */
 546
 547 VOID CloseUnit(struct IOSana2Req *request, struct DevBase *base)
 548 {
 549    struct DevUnit *unit;
 550    struct Opener *opener;
 551
 552    /* Free buffer-management resources */
 553
 554    base->device.dd_Library.lib_OpenCnt--;
 555    opener = (APTR)request->ios2_BufferManagement;
 556    if(opener != NULL)
 557    {
 558       Disable();
 559       Remove((APTR)opener);
 560       Enable();
 561       FreeVec(opener);
 562    }
 563
 564    /* Delete the unit if it's no longer in use */
 565
 566    unit = (APTR)request->ios2_Req.io_Unit;
 567    if(unit != NULL)
 568    {
 569       if((--unit->open_count) == 0)
 570       {
 571          Remove((APTR)unit);
 572          switch(unit->bus)
 573          {
 574          case PCI_BUS:
 575             DeletePCIUnit(unit, base);
 576             break;
 577 #ifndef __AROS__
 578          case PCCARD_BUS:
 579             DeletePCCardUnit(unit, base);
 580             break;
 581 #endif
 582          }
 583       }
 584    }
 585
 586    return;
 587 }
 588
 589
 590
 591 /****i* etherlink3.device/GetUnit ******************************************
 592 *
 593 *   NAME
 594 *       GetUnit -- Get a unit by number.
 595 *
 596 *   SYNOPSIS
 597 *       unit = GetUnit(unit_num)
 598 *
 599 *       struct DevUnit *GetUnit(ULONG);
 600 *
 601 ****************************************************************************
 602 *
 603 */
 604
 605 struct DevUnit *GetUnit(ULONG unit_num, struct DevBase *base)
 606 {
 607    struct DevUnit *unit;
 608    ULONG pci_limit, pccard_limit;
 609
 610    pci_limit = GetPCICount(base);
 611 #ifndef __AROS__
 612    pccard_limit = pci_limit + GetPCCardCount(base);
 613 #endif
 614
 615    if(unit_num < pci_limit)
 616       unit = GetPCIUnit(unit_num, base);
 617 #ifndef __AROS__
 618    else if(unit_num < pccard_limit)
 619       unit = GetPCCardUnit(unit_num - pci_limit, base);
 620 #endif
 621    else
 622       unit = NULL;
 623
 624    return unit;
 625 }
 626
 627
 628
 629 /****i* etherlink3.device/WrapInt ******************************************
 630 *
 631 *   NAME
 632 *       WrapInt
 633 *
 634 ****************************************************************************
 635 *
 636 */
 637
 638 BOOL WrapInt(struct Interrupt *interrupt, struct DevBase *base)
 639 {
 640    BOOL success = TRUE;
 641 #if defined(__amigaos4__) || defined(__MORPHOS__)
 642    APTR *int_data;
 643
 644    int_data = AllocMem(2 * sizeof(APTR), MEMF_PUBLIC | MEMF_CLEAR);
 645    if(int_data != NULL)
 646    {
 647       int_data[0] = interrupt->is_Code;
 648       int_data[1] = interrupt->is_Data;
 649       interrupt->is_Code = base->wrapper_int_code;
 650       interrupt->is_Data = int_data;
 651    }
 652    else
 653       success = FALSE;
 654 #endif
 655
 656    return success;
 657 }
 658
 659
 660
 661 /****i* etherlink3.device/UnwrapInt ****************************************
 662 *
 663 *   NAME
 664 *       UnwrapInt
 665 *
 666 ****************************************************************************
 667 *
 668 */
 669
 670 VOID UnwrapInt(struct Interrupt *interrupt, struct DevBase *base)
 671 {
 672    if(interrupt->is_Code == base->wrapper_int_code)
 673       FreeMem(interrupt->is_Data, 2 * sizeof(APTR));
 674
 675    return;
 676 }
 677
 678
 679