workbench/devs/networks/etherlink3/pccard.c

   1 /*
   2
   3 Copyright (C) 2000-2011 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 <utility/tagitem.h>
  25 #include <libraries/pccard.h>
  26
  27 #include <proto/exec.h>
  28 #include <proto/utility.h>
  29 #include <proto/cardres.h>
  30 #include <proto/pccard.h>
  31
  32 #include "device.h"
  33
  34 #include "pccard_protos.h"
  35 #include "device_protos.h"
  36 #include "unit_protos.h"
  37
  38 #define MAX_TUPLE_SIZE 0xff
  39 #define TUPLE_BUFFER_SIZE (MAX_TUPLE_SIZE + 8)
  40 #define HANDLE_PRIORITY 10
  41 #define IO_WINDOW_SIZE 0x10
  42
  43
  44 struct BusContext
  45 {
  46    struct DevUnit *unit;
  47    struct CardHandle *card_handle;
  48    UBYTE *tuple_buffer;
  49    UPINT config_base;
  50    UPINT io_base;
  51    UWORD resource_version;
  52    BOOL have_card;
  53 };
  54
  55
  56 /* Private prototypes */
  57
  58 static struct DevUnit *FindPCCardUnit(ULONG index, struct DevBase *base);
  59 static struct DevUnit *CreatePCCardUnit(ULONG index,
  60    struct DevBase *base);
  61 static struct BusContext *AllocCard(struct DevBase *base);
  62 static VOID FreeCard(struct BusContext *context, struct DevBase *base);
  63 static BOOL IsCardCompatible(struct BusContext *context,
  64    struct DevBase *base);
  65 static BOOL InitialiseCard(struct BusContext *context,
  66    struct DevBase *base);
  67 static VOID CardRemovedHook(struct BusContext *context,
  68    struct DevBase *base);
  69 static BOOL CardInsertedHook(struct BusContext *context,
  70    struct DevBase *base);
  71 static VOID CardRemovedInt(REG(a1, struct BusContext *context),
  72    REG(a6, APTR int_code));
  73 static VOID CardInsertedInt(REG(a1, struct BusContext *context),
  74    REG(a6, APTR int_code));
  75 static UBYTE CardStatusInt(REG(a1, struct BusContext *context),
  76    REG(a6, APTR int_code), REG(d0, UBYTE mask));
  77 static UBYTE ByteInHook(struct BusContext *context, ULONG offset);
  78 static ULONG LongInHook(struct BusContext *context, ULONG offset);
  79 static VOID ByteOutHook(struct BusContext *context, ULONG offset,
  80    UBYTE value);
  81 static VOID WordOutHook(struct BusContext *context, ULONG offset,
  82    UWORD value);
  83 static VOID LongOutHook(struct BusContext *context, ULONG offset,
  84    ULONG value);
  85 static VOID LongsInHook(struct BusContext *context, ULONG offset,
  86    ULONG *buffer, ULONG count);
  87 static VOID LongsOutHook(struct BusContext *context, ULONG offset,
  88    const ULONG *buffer, ULONG count);
  89 static VOID BEWordOutHook(struct BusContext *context, ULONG offset,
  90    UWORD value);
  91 static UWORD LEWordInHook(struct BusContext *context, ULONG offset);
  92 static ULONG LELongInHook(struct BusContext *context, ULONG offset);
  93 static VOID LEWordOutHook(struct BusContext *context, ULONG offset,
  94    UWORD value);
  95 static VOID LELongOutHook(struct BusContext *context, ULONG offset,
  96    ULONG value);
  97
  98
  99 static const ULONG product_codes[] =
 100 {
 101    0x01010035,
 102    0x0101003d,
 103    0x01010562,
 104    0x01010589,
 105    0
 106 };
 107
 108
 109 static const struct TagItem unit_tags[] =
 110 {
 111    {IOTAG_ByteIn, (UPINT)ByteInHook},
 112    {IOTAG_LongIn, (UPINT)LongInHook},
 113    {IOTAG_ByteOut, (UPINT)ByteOutHook},
 114    {IOTAG_WordOut, (UPINT)WordOutHook},
 115    {IOTAG_LongOut, (UPINT)LongOutHook},
 116    {IOTAG_LongsIn, (UPINT)LongsInHook},
 117    {IOTAG_LongsOut, (UPINT)LongsOutHook},
 118    {IOTAG_BEWordOut, (UPINT)BEWordOutHook},
 119    {IOTAG_LEWordIn, (UPINT)LEWordInHook},
 120    {IOTAG_LELongIn, (UPINT)LELongInHook},
 121    {IOTAG_LEWordOut, (UPINT)LEWordOutHook},
 122    {IOTAG_LELongOut, (UPINT)LELongOutHook},
 123    {TAG_END, 0}
 124 };
 125
 126
 127 /****i* etherlink3.device/GetPCCardCount ***********************************
 128 *
 129 *   NAME
 130 *       GetPCCardCount -- Get the number of compatible PC Cards.
 131 *
 132 *   SYNOPSIS
 133 *       count = GetPCCardCount()
 134 *
 135 *       ULONG GetPCCardCount();
 136 *
 137 ****************************************************************************
 138 *
 139 */
 140
 141 ULONG GetPCCardCount(struct DevBase *base)
 142 {
 143    ULONG count = 0;
 144    struct BusContext *context;
 145
 146    if(CardResource != NULL)
 147    {
 148       if(FindPCCardUnit(0, base) != NULL)
 149          count = 1;
 150       else
 151       {
 152          context = AllocCard(base);
 153          if(context != NULL)
 154          {
 155             count = 1;
 156             FreeCard(context, base);
 157          }
 158       }
 159    }
 160
 161    return count;
 162 }
 163
 164
 165
 166 /****i* etherlink3.device/GetPCCardUnit ************************************
 167 *
 168 *   NAME
 169 *       GetPCCardUnit -- Get a unit by number.
 170 *
 171 *   SYNOPSIS
 172 *       unit = GetPCCardUnit(index)
 173 *
 174 *       struct DevUnit *GetPCCardUnit(ULONG);
 175 *
 176 ****************************************************************************
 177 *
 178 */
 179
 180 struct DevUnit *GetPCCardUnit(ULONG index, struct DevBase *base)
 181 {
 182    struct DevUnit *unit;
 183
 184    unit = FindPCCardUnit(index, base);
 185
 186    if(unit == NULL)
 187    {
 188       unit = CreatePCCardUnit(index, base);
 189       if(unit != NULL)
 190          AddTail((APTR)&base->pccard_units, (APTR)unit);
 191    }
 192
 193    return unit;
 194 }
 195
 196
 197
 198 /****i* etherlink3.device/FindPCCardUnit ***********************************
 199 *
 200 *   NAME
 201 *       FindPCCardUnit -- Find a unit by number.
 202 *
 203 *   SYNOPSIS
 204 *       unit = FindPCCardUnit(index)
 205 *
 206 *       struct DevUnit *FindPCCardUnit(ULONG);
 207 *
 208 ****************************************************************************
 209 *
 210 */
 211
 212 static struct DevUnit *FindPCCardUnit(ULONG index, struct DevBase *base)
 213 {
 214    struct DevUnit *unit, *tail;
 215
 216    unit = (APTR)base->pccard_units.mlh_Head;
 217    tail = (APTR)&base->pccard_units.mlh_Tail;
 218    if(unit == tail)
 219       unit = NULL;
 220
 221    return unit;
 222 }
 223
 224
 225
 226 /****i* etherlink3.device/CreatePCCardUnit *********************************
 227 *
 228 *   NAME
 229 *       CreatePCCardUnit -- Create a unit.
 230 *
 231 *   SYNOPSIS
 232 *       unit = CreatePCCardUnit(index)
 233 *
 234 *       struct DevUnit *CreatePCCardUnit(ULONG);
 235 *
 236 *   FUNCTION
 237 *       Creates a new unit.
 238 *
 239 ****************************************************************************
 240 *
 241 */
 242
 243 static struct DevUnit *CreatePCCardUnit(ULONG index,
 244    struct DevBase *base)
 245 {
 246    BOOL success = TRUE;
 247    struct BusContext *context;
 248    struct DevUnit *unit;
 249
 250    /* Get card from system */
 251
 252    context = AllocCard(base);
 253    if(context == NULL)
 254       success = FALSE;
 255
 256    /* Prepare card for use */
 257
 258    if(success)
 259    {
 260       if(!InitialiseCard(context, base))
 261          success = FALSE;
 262    }
 263
 264    /* Create device driver unit */
 265
 266    if(success)
 267    {
 268       context->unit = unit =
 269          CreateUnit(index, context, unit_tags, SECOND_GEN,
 270             PCCARD_BUS, base);
 271       if(unit == NULL)
 272          success = FALSE;
 273    }
 274
 275    if(success)
 276    {
 277       if(!(WrapInt(&unit->status_int, base)
 278          && WrapInt(&unit->rx_int, base)
 279          && WrapInt(&unit->tx_int, base)
 280          && WrapInt(&unit->tx_end_int, base)))
 281          success = FALSE;
 282
 283       unit->insertion_function = (APTR)CardInsertedHook;
 284       unit->removal_function = (APTR)CardRemovedHook;
 285    }
 286
 287    if(!success)
 288    {
 289       if(context != NULL)
 290       {
 291          DeleteUnit(context->unit, base);
 292          FreeCard(context, base);
 293       }
 294       unit = NULL;
 295    }
 296
 297    return unit;
 298 }
 299
 300
 301
 302 /****i* etherlink3.device/DeletePCCardUnit *********************************
 303 *
 304 *   NAME
 305 *       DeletePCCardUnit -- Delete a unit.
 306 *
 307 *   SYNOPSIS
 308 *       DeletePCCardUnit(unit)
 309 *
 310 *       VOID DeletePCCardUnit(struct DevUnit *);
 311 *
 312 *   FUNCTION
 313 *       Deletes a unit.
 314 *
 315 *   INPUTS
 316 *       unit - Device unit (may be NULL).
 317 *
 318 *   RESULT
 319 *       None.
 320 *
 321 ****************************************************************************
 322 *
 323 */
 324
 325 VOID DeletePCCardUnit(struct DevUnit *unit, struct DevBase *base)
 326 {
 327    struct BusContext *context;
 328
 329    if(unit != NULL)
 330    {
 331       UnwrapInt(&unit->tx_end_int, base);
 332       UnwrapInt(&unit->tx_int, base);
 333       UnwrapInt(&unit->rx_int, base);
 334       UnwrapInt(&unit->status_int, base);
 335       context = unit->card;
 336       DeleteUnit(unit, base);
 337       context->unit = NULL;
 338       FreeCard(context, base);
 339    }
 340
 341    return;
 342 }
 343
 344
 345
 346 /****i* etherlink3.device/AllocCard ****************************************
 347 *
 348 *   NAME
 349 *       AllocCard -- Get card from system.
 350 *
 351 *   SYNOPSIS
 352 *       context = AllocCard()
 353 *
 354 *       struct BusContext *AllocCard();
 355 *
 356 ****************************************************************************
 357 *
 358 */
 359
 360 static struct BusContext *AllocCard(struct DevBase *base)
 361 {
 362    BOOL success = TRUE, have_card = FALSE;
 363    struct BusContext *context;
 364    struct CardHandle *card_handle;
 365    struct Interrupt *card_removed_int, *card_inserted_int, *card_status_int;
 366
 367    context = AllocMem(sizeof(struct BusContext), MEMF_PUBLIC | MEMF_CLEAR);
 368    if(context == NULL)
 369       success = FALSE;
 370
 371    if(success)
 372    {
 373       context->resource_version =
 374          ((struct Library *)base->card_base)->lib_Version;
 375       context->card_handle = card_handle =
 376          AllocMem(sizeof(struct CardHandle), MEMF_PUBLIC | MEMF_CLEAR);
 377       context->tuple_buffer =
 378          AllocVec(TUPLE_BUFFER_SIZE, MEMF_PUBLIC);
 379
 380       if(card_handle == NULL || context->tuple_buffer == NULL)
 381          success = FALSE;
 382    }
 383
 384    if(success)
 385    {
 386       /* Set up card handle */
 387
 388       card_handle->cah_CardNode.ln_Pri = HANDLE_PRIORITY;
 389       card_handle->cah_CardNode.ln_Name =
 390          base->device.dd_Library.lib_Node.ln_Name;
 391       card_handle->cah_CardFlags = CARDF_POSTSTATUS;
 392
 393       card_handle->cah_CardRemoved = card_removed_int =
 394          AllocVec(sizeof(struct Interrupt), MEMF_PUBLIC | MEMF_CLEAR);
 395
 396       card_handle->cah_CardInserted = card_inserted_int =
 397          AllocVec(sizeof(struct Interrupt), MEMF_PUBLIC | MEMF_CLEAR);
 398
 399       card_handle->cah_CardStatus = card_status_int =
 400          AllocVec(sizeof(struct Interrupt), MEMF_PUBLIC | MEMF_CLEAR);
 401
 402       if(card_removed_int == NULL || card_inserted_int == NULL
 403          || card_status_int == NULL)
 404          success = FALSE;
 405    }
 406
 407    if(success)
 408    {
 409       /* Try to gain access to card */
 410
 411       card_removed_int->is_Code = CardRemovedInt;
 412       card_removed_int->is_Data = context;
 413       card_inserted_int->is_Code = CardInsertedInt;
 414       card_inserted_int->is_Data = context;
 415       card_status_int->is_Code = (APTR)CardStatusInt;
 416       card_status_int->is_Data = context;
 417
 418       if(!(WrapInt(card_removed_int, base)
 419          && WrapInt(card_inserted_int, base)
 420          && WrapInt(card_status_int, base)))
 421          success = FALSE;
 422    }
 423
 424    if(success)
 425    {
 426       if(OwnCard(card_handle) != 0)
 427          success = FALSE;
 428    }
 429
 430    if(success)
 431    {
 432       have_card = TRUE;
 433       if(!IsCardCompatible(context, base))
 434          success = FALSE;
 435    }
 436
 437    if(!success)
 438    {
 439       FreeCard(context, base);
 440       context = NULL;
 441    }
 442    return context;
 443 }
 444
 445
 446
 447 /****i* etherlink3.device/FreeCard *****************************************
 448 *
 449 *   NAME
 450 *       FreeCard -- Release a card.
 451 *
 452 *   SYNOPSIS
 453 *       FreeCard(context)
 454 *
 455 *       VOID FreeCard(struct BusContext *);
 456 *
 457 ****************************************************************************
 458 *
 459 */
 460
 461 static VOID FreeCard(struct BusContext *context, struct DevBase *base)
 462 {
 463    struct CardHandle *card_handle;
 464
 465    if(context != NULL)
 466    {
 467       card_handle = context->card_handle;
 468
 469       if(context->have_card)
 470       {
 471          CardMiscControl(card_handle, 0);
 472          CardResetCard(card_handle);
 473       }
 474       ReleaseCard(card_handle, CARDF_REMOVEHANDLE);
 475       UnwrapInt(card_handle->cah_CardStatus, base);
 476       UnwrapInt(card_handle->cah_CardInserted, base);
 477       UnwrapInt(card_handle->cah_CardRemoved, base);
 478
 479       FreeVec(card_handle->cah_CardStatus);
 480       FreeVec(card_handle->cah_CardInserted);
 481       FreeVec(card_handle->cah_CardRemoved);
 482       FreeVec(context->tuple_buffer);
 483       FreeMem(card_handle, sizeof(struct CardHandle));
 484
 485       FreeMem(context, sizeof(struct BusContext));
 486    }
 487
 488    return;
 489 }
 490
 491
 492
 493 /****i* etherlink3.device/IsCardCompatible *********************************
 494 *
 495 *   NAME
 496 *       IsCardCompatible
 497 *
 498 *   SYNOPSIS
 499 *       compatible = IsCardCompatible(context)
 500 *
 501 *       BOOL IsCardCompatible(struct BusContext *);
 502 *
 503 ****************************************************************************
 504 *
 505 */
 506
 507 static BOOL IsCardCompatible(struct BusContext *context,
 508    struct DevBase *base)
 509 {
 510    BOOL success = TRUE;
 511    struct CardHandle *card_handle;
 512    UBYTE *tuple_buffer;
 513    const struct TagItem *tuple_tags = NULL;
 514    ULONG code;
 515    const ULONG *p;
 516    UWORD maker = 0, product = 0;
 517
 518    card_handle = context->card_handle;
 519    tuple_buffer = context->tuple_buffer;
 520
 521    /* Get card's make and model */
 522
 523    if(CopyTuple(card_handle, tuple_buffer, PCCARD_TPL_MANFID,
 524       MAX_TUPLE_SIZE))
 525    {
 526       tuple_tags = PCCard_GetTupleInfo(tuple_buffer);
 527       if(tuple_tags != NULL)
 528       {
 529          maker = GetTagData(PCCARD_Maker, 0, tuple_tags);
 530          product = GetTagData(PCCARD_Product, 0, tuple_tags);
 531       }
 532    }
 533
 534    /* Check this is a card we can use */
 535
 536    code = maker << 16 | product;
 537    for(success = FALSE, p = product_codes; *p != 0; p++)
 538       if(*p == code)
 539          success = TRUE;
 540    PCCard_FreeTupleInfo(tuple_tags);
 541
 542    return success;
 543 }
 544
 545
 546
 547 /****i* etherlink3.device/InitialiseCard ***********************************
 548 *
 549 *   NAME
 550 *       InitialiseCard
 551 *
 552 *   SYNOPSIS
 553 *       success = InitialiseCard(context)
 554 *
 555 *       BOOL InitialiseCard(struct BusContext *);
 556 *
 557 ****************************************************************************
 558 *
 559 */
 560
 561 static BOOL InitialiseCard(struct BusContext *context,
 562    struct DevBase *base)
 563 {
 564    BOOL success = TRUE;
 565    struct CardHandle *card_handle;
 566    struct CardMemoryMap *card_map;
 567    UBYTE config_value, i, window_count, *tuple_buffer;
 568    const struct TagItem *tuple_tags = NULL;
 569    ULONG *io_bases, *io_lengths, io_base_offset = 0, config_base_offset;
 570
 571    /* Wake up card's I/O functionality */
 572
 573    card_handle = context->card_handle;
 574    tuple_buffer = context->tuple_buffer;
 575    CardMiscControl(card_handle,
 576       CARD_ENABLEF_DIGAUDIO | CARD_DISABLEF_WP);
 577
 578    /* Get configuration data */
 579
 580    if(!CopyTuple(card_handle, tuple_buffer, PCCARD_TPL_CONFIG,
 581       MAX_TUPLE_SIZE))
 582       success = FALSE;
 583
 584    if(success)
 585    {
 586       PCCard_FreeTupleInfo(tuple_tags);
 587       tuple_tags = PCCard_GetTupleInfo(tuple_buffer);
 588       if(tuple_tags == NULL)
 589          success = FALSE;
 590    }
 591
 592    if(success)
 593    {
 594       config_base_offset = GetTagData(PCCARD_RegisterBase, 0, tuple_tags);
 595
 596       PCCard_FreeTupleInfo(tuple_tags);
 597       tuple_tags = NULL;
 598
 599       /* Get IO base */
 600
 601       if(!CopyTuple(card_handle, tuple_buffer, PCCARD_TPL_CFTABLEENTRY,
 602          MAX_TUPLE_SIZE))
 603          success = FALSE;
 604    }
 605
 606    if(success)
 607    {
 608       tuple_tags = PCCard_GetTupleInfo(tuple_buffer);
 609       if(tuple_tags == NULL)
 610          success = FALSE;
 611    }
 612
 613    if(success)
 614    {
 615       config_value = GetTagData(PCCARD_ModeNo, 0, tuple_tags);
 616
 617       io_bases =
 618          (APTR)GetTagData(PCCARD_IOWinBases, (UPINT)NULL, tuple_tags);
 619       if(io_bases == NULL)
 620          success = FALSE;
 621    }
 622
 623    /* Find the appropriate IO window */
 624
 625    if(success)
 626    {
 627       io_lengths =
 628          (APTR)GetTagData(PCCARD_IOWinLengths, (UPINT)NULL, tuple_tags);
 629
 630       window_count = GetTagData(PCCARD_IOWinCount, 0, tuple_tags);
 631
 632       for(i = 0; i < window_count && io_base_offset == 0; i++)
 633          if(io_lengths[i] == IO_WINDOW_SIZE)
 634             io_base_offset = io_bases[i];
 635    }
 636
 637    PCCard_FreeTupleInfo(tuple_tags);
 638
 639    /* Configure card */
 640
 641    if(success)
 642    {
 643       card_map = GetCardMap();
 644       context->config_base =
 645          (UPINT)card_map->cmm_AttributeMemory + config_base_offset;
 646
 647       context->io_base = (UPINT)card_map->cmm_IOMemory + io_base_offset;
 648       BYTEOUT(context->config_base + PCCARD_REG_COR, config_value);
 649       BYTEOUT(context->config_base + PCCARD_REG_CCSR,
 650          BYTEIN(context->config_base + PCCARD_REG_CCSR)
 651          | PCCARD_REG_CCSRF_AUDIOENABLE);
 652    }
 653
 654    return success;
 655 }
 656
 657
 658
 659 /****i* etherlink3.device/CardRemovedHook **********************************
 660 *
 661 *   NAME
 662 *       CardRemovedHook
 663 *
 664 *   SYNOPSIS
 665 *       CardRemovedHook(context)
 666 *
 667 *       VOID CardRemovedHook(struct BusContext *);
 668 *
 669 ****************************************************************************
 670 *
 671 */
 672
 673 static VOID CardRemovedHook(struct BusContext *context,
 674    struct DevBase *base)
 675 {
 676    ReleaseCard(context->card_handle, 0);
 677
 678    return;
 679 }
 680
 681
 682
 683 /****i* etherlink3.device/CardInsertedHook *********************************
 684 *
 685 *   NAME
 686 *       CardInsertedHook
 687 *
 688 *   SYNOPSIS
 689 *       success = CardInsertedHook(context)
 690 *
 691 *       BOOL CardInsertedHook(struct BusContext *);
 692 *
 693 ****************************************************************************
 694 *
 695 */
 696
 697 static BOOL CardInsertedHook(struct BusContext *context,
 698    struct DevBase *base)
 699 {
 700    BOOL success = TRUE;
 701
 702    success = IsCardCompatible(context, base);
 703
 704    if(success)
 705       success = InitialiseCard(context, base);
 706
 707    if(success)
 708       success = InitialiseAdapter(context->unit, TRUE, base);
 709
 710    if(!success)
 711       ReleaseCard(context->card_handle, 0);
 712
 713    return success;
 714 }
 715
 716
 717
 718 /****i* etherlink3.device/CardRemovedInt ***********************************
 719 *
 720 *   NAME
 721 *       CardRemovedInt
 722 *
 723 *   SYNOPSIS
 724 *       CardRemovedInt(context, int_code)
 725 *
 726 *       VOID CardRemovedInt(struct BusContext *, APTR);
 727 *
 728 ****************************************************************************
 729 *
 730 */
 731
 732 static VOID CardRemovedInt(REG(a1, struct BusContext *context),
 733    REG(a6, APTR int_code))
 734 {
 735    struct DevBase *base;
 736    struct DevUnit *unit;
 737
 738    /* Record loss of card and get our task to call ReleaseCard() */
 739
 740    unit = context->unit;
 741    if(unit != NULL)
 742    {
 743       base = unit->device;
 744       if((unit->flags & UNITF_ONLINE) != 0)
 745          unit->flags |= UNITF_WASONLINE;
 746       unit->flags &= ~(UNITF_HAVEADAPTER | UNITF_ONLINE);
 747    }
 748    context->have_card = FALSE;
 749    if(unit != NULL)
 750       Signal(unit->task, unit->card_removed_signal);
 751
 752    return;
 753 }
 754
 755
 756
 757 /****i* etherlink3.device/CardInsertedInt **********************************
 758 *
 759 *   NAME
 760 *       CardInsertedInt
 761 *
 762 *   SYNOPSIS
 763 *       CardInsertedInt(context, int_code)
 764 *
 765 *       VOID CardInsertedInt(struct BusContext *, APTR);
 766 *
 767 ****************************************************************************
 768 *
 769 */
 770
 771 static VOID CardInsertedInt(REG(a1, struct BusContext *context),
 772    REG(a6, APTR int_code))
 773 {
 774    struct DevBase *base;
 775    struct DevUnit *unit;
 776
 777    unit = context->unit;
 778    base = unit->device;
 779    context->have_card = TRUE;
 780    Signal(unit->task, unit->card_inserted_signal);
 781
 782    return;
 783 }
 784
 785
 786
 787 /****i* etherlink3.device/CardStatusInt ************************************
 788 *
 789 *   NAME
 790 *       CardStatusInt
 791 *
 792 *   SYNOPSIS
 793 *       mask = CardStatusInt(context, int_code, mask)
 794 *
 795 *       UBYTE CardStatusInt(struct BusContext *, APTR, UBYTE);
 796 *
 797 ****************************************************************************
 798 *
 799 * We pretend the int_code parameter goes in A6 rather than A5 because 68k
 800 * GCC can't cope with A5 and we know the parameter isn't used in this case.
 801 *
 802 */
 803
 804 static UBYTE CardStatusInt(REG(a1, struct BusContext *context),
 805    REG(a6, APTR int_code), REG(d0, UBYTE mask))
 806 {
 807    if(context->resource_version < 39)
 808    {
 809       /* Work around gayle interrupt bug */
 810
 811       *((volatile UBYTE *)0xda9000) = (mask ^ 0x2c) | 0xc0;
 812       mask = 0;
 813    }
 814
 815    if(context->unit != NULL)
 816       StatusInt(context->unit, StatusInt);
 817
 818    return mask;
 819 }
 820
 821
 822
 823 /****i* etherlink3.device/ByteInHook ***************************************
 824 *
 825 *   NAME
 826 *       ByteInHook
 827 *
 828 *   SYNOPSIS
 829 *       value = ByteInHook(context, offset)
 830 *
 831 *       UBYTE ByteInHook(struct BusContext *, ULONG);
 832 *
 833 ****************************************************************************
 834 *
 835 */
 836
 837 static UBYTE ByteInHook(struct BusContext *context, ULONG offset)
 838 {
 839    return BYTEIN(context->io_base + offset);
 840 }
 841
 842
 843
 844 /****i* etherlink3.device/LongInHook ***************************************
 845 *
 846 *   NAME
 847 *       LongInHook
 848 *
 849 *   SYNOPSIS
 850 *       value = LongInHook(context, offset)
 851 *
 852 *       ULONG LongInHook(struct BusContext *, ULONG);
 853 *
 854 ****************************************************************************
 855 *
 856 */
 857
 858 static ULONG LongInHook(struct BusContext *context, ULONG offset)
 859 {
 860    return LONGIN(context->io_base + offset);
 861 }
 862
 863
 864
 865 /****i* etherlink3.device/ByteOutHook **************************************
 866 *
 867 *   NAME
 868 *       ByteOutHook
 869 *
 870 *   SYNOPSIS
 871 *       ByteOutHook(context, offset, value)
 872 *
 873 *       VOID ByteOutHook(struct BusContext *, ULONG, UBYTE);
 874 *
 875 ****************************************************************************
 876 *
 877 */
 878
 879 static VOID ByteOutHook(struct BusContext *context, ULONG offset,
 880    UBYTE value)
 881 {
 882    BYTEOUT(context->io_base + offset, value);
 883
 884    return;
 885 }
 886
 887
 888
 889 /****i* etherlink3.device/WordOutHook **************************************
 890 *
 891 *   NAME
 892 *       WordOutHook
 893 *
 894 *   SYNOPSIS
 895 *       WordOutHook(context, offset, value)
 896 *
 897 *       VOID WordOutHook(struct BusContext *, ULONG, UWORD);
 898 *
 899 ****************************************************************************
 900 *
 901 */
 902
 903 static VOID WordOutHook(struct BusContext *context, ULONG offset,
 904    UWORD value)
 905 {
 906    WORDOUT(context->io_base + offset, value);
 907
 908    return;
 909 }
 910
 911
 912
 913 /****i* etherlink3.device/LongOutHook **************************************
 914 *
 915 *   NAME
 916 *       LongOutHook
 917 *
 918 *   SYNOPSIS
 919 *       LongOutHook(context, offset, value)
 920 *
 921 *       VOID LongOutHook(struct BusContext *, ULONG, ULONG);
 922 *
 923 ****************************************************************************
 924 *
 925 */
 926
 927 static VOID LongOutHook(struct BusContext *context, ULONG offset,
 928    ULONG value)
 929 {
 930    LONGOUT(context->io_base + offset, value);
 931
 932    return;
 933 }
 934
 935
 936
 937 /****i* etherlink3.device/LongsInHook **************************************
 938 *
 939 *   NAME
 940 *       LongsInHook
 941 *
 942 *   SYNOPSIS
 943 *       LongsInHook(context, offset, buffer, count)
 944 *
 945 *       VOID LongsInHook(struct BusContext *, ULONG, ULONG *, ULONG);
 946 *
 947 ****************************************************************************
 948 *
 949 */
 950
 951 static VOID LongsInHook(struct BusContext *context, ULONG offset,
 952    ULONG *buffer, ULONG count)
 953 {
 954    LONGSIN(context->io_base + offset, buffer, count);
 955
 956    return;
 957 }
 958
 959
 960
 961 /****i* etherlink3.device/LongsOutHook *************************************
 962 *
 963 *   NAME
 964 *       LongsOutHook
 965 *
 966 *   SYNOPSIS
 967 *       LongsOutHook(context, offset, buffer, count)
 968 *
 969 *       VOID LongsOutHook(struct BusContext *, ULONG, const ULONG *, ULONG);
 970 *
 971 ****************************************************************************
 972 *
 973 */
 974
 975 static VOID LongsOutHook(struct BusContext *context, ULONG offset,
 976    const ULONG *buffer, ULONG count)
 977 {
 978    LONGSOUT(context->io_base + offset, buffer, count);
 979
 980    return;
 981 }
 982
 983
 984
 985 /****i* etherlink3.device/BEWordOutHook ************************************
 986 *
 987 *   NAME
 988 *       BEWordOutHook
 989 *
 990 *   SYNOPSIS
 991 *       BEWordOutHook(context, offset, value)
 992 *
 993 *       VOID BEWordOutHook(struct BusContext *, ULONG, UWORD);
 994 *
 995 ****************************************************************************
 996 *
 997 */
 998
 999 static VOID BEWordOutHook(struct BusContext *context, ULONG offset,
1000    UWORD value)
1001 {
1002    BEWORDOUT(context->io_base + offset, value);
1003
1004    return;
1005 }
1006
1007
1008
1009 /****i* etherlink3.device/LEWordInHook *************************************
1010 *
1011 *   NAME
1012 *       LEWordInHook
1013 *
1014 *   SYNOPSIS
1015 *       value = LEWordInHook(context, offset)
1016 *
1017 *       UWORD LEWordInHook(struct BusContext *, ULONG);
1018 *
1019 ****************************************************************************
1020 *
1021 */
1022
1023 static UWORD LEWordInHook(struct BusContext *context, ULONG offset)
1024 {
1025    return LEWORDIN(context->io_base + offset);
1026 }
1027
1028
1029
1030 /****i* etherlink3.device/LELongInHook ***************************************
1031 *
1032 *   NAME
1033 *       LELongInHook
1034 *
1035 *   SYNOPSIS
1036 *       value = LELongInHook(context, offset)
1037 *
1038 *       ULONG LELongInHook(struct BusContext *, ULONG);
1039 *
1040 ****************************************************************************
1041 *
1042 */
1043
1044 static ULONG LELongInHook(struct BusContext *context, ULONG offset)
1045 {
1046    return LELONGIN(context->io_base + offset);
1047 }
1048
1049
1050
1051 /****i* etherlink3.device/LEWordOutHook ************************************
1052 *
1053 *   NAME
1054 *       LEWordOutHook
1055 *
1056 *   SYNOPSIS
1057 *       LEWordOutHook(context, offset, value)
1058 *
1059 *       VOID LEWordOutHook(struct BusContext *, ULONG, UWORD);
1060 *
1061 ****************************************************************************
1062 *
1063 */
1064
1065 static VOID LEWordOutHook(struct BusContext *context, ULONG offset,
1066    UWORD value)
1067 {
1068    LEWORDOUT(context->io_base + offset, value);
1069
1070    return;
1071 }
1072
1073
1074
1075 /****i* etherlink3.device/LELongOutHook ************************************
1076 *
1077 *   NAME
1078 *       LELongOutHook
1079 *
1080 *   SYNOPSIS
1081 *       LELongOutHook(context, offset, value)
1082 *
1083 *       VOID LELongOutHook(struct BusContext *, ULONG, ULONG);
1084 *
1085 ****************************************************************************
1086 *
1087 */
1088
1089 static VOID LELongOutHook(struct BusContext *context, ULONG offset,
1090    ULONG value)
1091 {
1092    LELONGOUT(context->io_base + offset, value);
1093
1094    return;
1095 }
1096
1097
1098