workbench/devs/networks/etherlink3/pccard.c

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