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