workbench/devs/networks/etherlink3/isa.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/utility.h>*/
  25 #include <libraries/isapnp.h>
  26
  27 #include <proto/exec.h>
  28 #include <proto/utility.h>
  29 #include <proto/isapnp.h>
  30
  31 #include "device.h"
  32
  33 #include "isa_protos.h"
  34 #include "unit_protos.h"
  35
  36
  37 struct BusContext
  38 {
  39    struct DevUnit *unit;
  40    struct ISAPNP_Device *card;
  41    UPINT io_base;
  42    APTR lock;
  43 };
  44
  45
  46 /* Private prototypes */
  47
  48 static struct DevUnit *FindISAUnit(ULONG index, struct DevBase *base);
  49 static struct DevUnit *CreateISAUnit(ULONG index, struct DevBase *base);
  50 static struct BusContext *AllocCard(ULONG index, struct DevBase *base);
  51 static VOID FreeCard(struct BusContext *card, struct DevBase *base);
  52 static BOOL IsCardCompatible(struct ISAPNP_Device *card,
  53    struct DevBase *base);
  54 /*static BOOL InitialiseCard(struct BusContext *card, struct DevBase *base);*/
  55 static UBYTE ByteInHook(struct BusContext *context, ULONG offset);
  56 static ULONG LongInHook(struct BusContext *context, ULONG offset);
  57 static VOID ByteOutHook(struct BusContext *context, ULONG offset,
  58    UBYTE value);
  59 static VOID WordOutHook(struct BusContext *context, ULONG offset,
  60    UWORD value);
  61 static VOID LongOutHook(struct BusContext *context, ULONG offset,
  62    ULONG value);
  63 static VOID LongsInHook(struct BusContext *context, ULONG offset,
  64    ULONG *buffer, ULONG count);
  65 static VOID LongsOutHook(struct BusContext *context, ULONG offset,
  66    const ULONG *buffer, ULONG count);
  67 static VOID BEWordOutHook(struct BusContext *context, ULONG offset,
  68    UWORD value);
  69 static UWORD LEWordInHook(struct BusContext *context, ULONG offset);
  70 static ULONG LELongInHook(struct BusContext *context, ULONG offset);
  71 static VOID LEWordOutHook(struct BusContext *context, ULONG offset,
  72    UWORD value);
  73 static VOID LELongOutHook(struct BusContext *context, ULONG offset,
  74    ULONG value);
  75
  76
  77 static const UWORD product_codes[] =
  78 {
  79    0x6d50, 0x5090,
  80    0x6d50, 0x5091,
  81    0x6d50, 0x5094,
  82    0x6d50, 0x5095,
  83    0x6d50, 0x5098,
  84 /*   'PNP', 0x80f7,
  85    'PNP', 0x80f8,*/
  86    0
  87 };
  88
  89
  90 static const struct TagItem unit_tags[] =
  91 {
  92    {IOTAG_ByteIn, (UPINT)ByteInHook},
  93    {IOTAG_LongIn, (UPINT)LongInHook},
  94    {IOTAG_ByteOut, (UPINT)ByteOutHook},
  95    {IOTAG_WordOut, (UPINT)WordOutHook},
  96    {IOTAG_LongOut, (UPINT)LongOutHook},
  97    {IOTAG_LongsIn, (UPINT)LongsInHook},
  98    {IOTAG_LongsOut, (UPINT)LongsOutHook},
  99    {IOTAG_BEWordOut, (UPINT)BEWordOutHook},
 100    {IOTAG_LEWordIn, (UPINT)LEWordInHook},
 101    {IOTAG_LELongIn, (UPINT)LELongInHook},
 102    {IOTAG_LEWordOut, (UPINT)LEWordOutHook},
 103    {IOTAG_LELongOut, (UPINT)LELongOutHook},
 104    {TAG_END, 0}
 105 };
 106
 107
 108 /****i* etherlink3.device/GetISACount **************************************
 109 *
 110 *   NAME
 111 *       GetISACount -- Get the number of compatible ISA cards.
 112 *
 113 *   SYNOPSIS
 114 *       count = GetISACount()
 115 *
 116 *       ULONG GetISACount();
 117 *
 118 ****************************************************************************
 119 *
 120 */
 121
 122 ULONG GetISACount(struct DevBase *base)
 123 {
 124    ULONG count = 0;
 125    struct ISAPNP_Device *card = NULL;
 126
 127    while((card = ISAPNP_FindDevice(card, -1, -1, -1)) != NULL)
 128    {
 129       if(IsCardCompatible(card, base))
 130          count++;
 131    }
 132
 133    return count;
 134 }
 135
 136
 137
 138 /****i* etherlink3.device/GetISAUnit ***************************************
 139 *
 140 *   NAME
 141 *       GetISAUnit -- Get a unit by number.
 142 *
 143 *   SYNOPSIS
 144 *       unit = GetISAUnit(index)
 145 *
 146 *       struct DevUnit *GetISAUnit(ULONG);
 147 *
 148 ****************************************************************************
 149 *
 150 */
 151
 152 struct DevUnit *GetISAUnit(ULONG index, struct DevBase *base)
 153 {
 154    struct DevUnit *unit;
 155    struct BusContext *card;
 156
 157    unit = FindISAUnit(index, base);
 158
 159    if(unit == NULL)
 160    {
 161       card = CreateISAUnit(index, base);
 162       if(card != NULL)
 163       {
 164          unit = card->unit;
 165          AddTail((APTR)&base->isa_units, (APTR)unit);
 166       }
 167    }
 168
 169    return unit;
 170 }
 171
 172
 173
 174 /****i* etherlink3.device/FindISAUnit **************************************
 175 *
 176 *   NAME
 177 *       FindISAUnit -- Find an existing unit by number.
 178 *
 179 *   SYNOPSIS
 180 *       unit = FindISAUnit(index)
 181 *
 182 *       struct DevUnit *FindISAUnit(ULONG);
 183 *
 184 ****************************************************************************
 185 *
 186 */
 187
 188 static struct DevUnit *FindISAUnit(ULONG index, struct DevBase *base)
 189 {
 190    struct DevUnit *unit, *tail;
 191    BOOL found = FALSE;
 192
 193    unit = (APTR)base->isa_units.mlh_Head;
 194    tail = (APTR)&base->isa_units.mlh_Tail;
 195
 196    while(unit != tail && !found)
 197    {
 198       if(unit->index == index)
 199          found = TRUE;
 200       else
 201          unit = (APTR)unit->node.mln_Succ;
 202    }
 203
 204    if(!found)
 205       unit = NULL;
 206
 207    return unit;
 208 }
 209
 210
 211
 212 /****i* etherlink3.device/CreateISAUnit ************************************
 213 *
 214 *   NAME
 215 *       CreateISAUnit -- Create an ISA unit.
 216 *
 217 *   SYNOPSIS
 218 *       unit = CreateISAUnit(index)
 219 *
 220 *       struct DevUnit *CreateISAUnit(ULONG);
 221 *
 222 *   FUNCTION
 223 *       Creates a new ISA unit.
 224 *
 225 ****************************************************************************
 226 *
 227 */
 228
 229 struct DevUnit *CreateISAUnit(ULONG index, struct DevBase *base)
 230 {
 231    BOOL success = TRUE;
 232    struct BusContext *context;
 233    struct DevUnit *unit;
 234    UWORD generation, id, i;
 235    UPINT io_base, id_port;
 236
 237    context = AllocCard(index, base);
 238    if(context == NULL)
 239       success = FALSE;
 240
 241
 242
 243 #if 0   /* Stuff below is for non-PnP only? */
 244
 245    /* Send initialisation ID sequence */
 246
 247    id_port = 0xef0100;   /* !!! */
 248    BYTEOUT(id_port, 0);
 249    BYTEOUT(id_port, 0);
 250
 251    id = 0xff;
 252    for(i = 0; i < 0xff; i++)
 253    {
 254       BYTEOUT(id_port, (UBYTE)id);
 255       id <<= 1;
 256       if ((id & 0x100) != 0)
 257          id ^= 0xcf;
 258    }
 259
 260    /* Activate adapter */
 261
 262    BYTEOUT(id_port, 0xff);
 263
 264    io_base = 0xef0300;
 265    generation = FIRST_GEN;
 266 #endif
 267
 268
 269    if(success)
 270    {
 271       generation = SECOND_GEN;
 272       unit = CreateUnit(unit_num, NULL, io_base, generation, ISA_BUS, base);
 273       if(unit == NULL)
 274          success = FALSE;
 275    }
 276
 277    /* Add interrupt */
 278
 279    if(success)
 280       AddIntServer(x, &unit->status_int);
 281
 282    if(!success)
 283    {
 284       DeleteISAUnit(unit, base);
 285       unit = NULL;
 286    }
 287
 288    return unit;
 289 }
 290
 291
 292
 293 /****i* etherlink3.device/DeleteISAUnit ************************************
 294 *
 295 *   NAME
 296 *       DeleteISAUnit -- Delete a unit.
 297 *
 298 *   SYNOPSIS
 299 *       DeleteISAUnit(unit)
 300 *
 301 *       VOID DeleteISAUnit(struct DevUnit *);
 302 *
 303 *   FUNCTION
 304 *       Deletes a unit.
 305 *
 306 *   INPUTS
 307 *       unit - Device unit (can be NULL).
 308 *
 309 *   RESULT
 310 *       None.
 311 *
 312 ****************************************************************************
 313 *
 314 */
 315
 316 VOID DeleteISAUnit(struct DevUnit *unit, struct DevBase *base)
 317 {
 318    if(unit != NULL)
 319    {
 320       RemIntServer(x, &unit->status_int);
 321       DeleteUnit(unit, base);
 322    }
 323
 324    return;
 325 }
 326
 327
 328
 329 /****i* etherlink3.device/AllocCard ****************************************
 330 *
 331 *   NAME
 332 *       AllocCard -- Get card from system.
 333 *
 334 *   SYNOPSIS
 335 *       context = AllocCard(index)
 336 *
 337 *       struct BusContext *AllocCard(ULONG);
 338 *
 339 ****************************************************************************
 340 *
 341 */
 342
 343 static struct BusContext *AllocCard(ULONG index, struct DevBase *base)
 344 {
 345    BOOL success = TRUE;
 346    struct BusContext *context;
 347    struct ISAPNP_Device *card = NULL;
 348    ULONG i;
 349
 350    /* Find a compatible card */
 351
 352    card = AllocMem(sizeof(struct BusContext), MEMF_PUBLIC | MEMF_CLEAR);
 353    if(card == NULL)
 354       success = FALSE;
 355
 356    if(success)
 357    {
 358       while(i <= index)
 359       {
 360          card = ISAPNP_FindDevice(card, -1, -1, -1);
 361          if(IsCardCompatible(card, base))
 362             i++;
 363       }
 364       context->card = card;
 365    }
 366
 367    /* Get base address */
 368
 369    if(success)
 370    {
 371    }
 372
 373    /* Lock card */
 374
 375    if(success)
 376    {
 377       context->lock = ISAPNP_LockDevices(ISAPNP_LOCKF_NONE, card);
 378       if(context->lock == NULL)
 379          success = FALSE;
 380    }
 381
 382    if(!success)
 383    {
 384       FreeCard(context, base);
 385    }
 386
 387    return card;
 388 }
 389
 390
 391
 392 /****i* etherlink3.device/FreeCard *****************************************
 393 *
 394 *   NAME
 395 *       FreeCard -- Release a card
 396 *
 397 *   SYNOPSIS
 398 *       FreeCard(context)
 399 *
 400 *       VOID FreeCard(struct BusContext *);
 401 *
 402 ****************************************************************************
 403 *
 404 */
 405
 406 static VOID FreeCard(struct BusContext *context, struct DevBase *base)
 407 {
 408    struct ISAPNP_Device *card = NULL;
 409
 410    if(context != NULL)
 411    {
 412       /* Unlock card */
 413
 414       ISAPNP_UnlockDevices(context->lock);
 415
 416       FreeMem(context, sizeof(struct BusContext));
 417    }
 418
 419    return;
 420 }
 421
 422
 423
 424 /****i* etherlink3.device/IsCardCompatible *********************************
 425 *
 426 *   NAME
 427 *       IsCardCompatible
 428 *
 429 *   SYNOPSIS
 430 *       compatible = IsCardCompatible(card)
 431 *
 432 *       BOOL IsCardCompatible(struct ISAPNP_Device *);
 433 *
 434 ****************************************************************************
 435 *
 436 */
 437
 438 static BOOL IsCardCompatible(struct ISAPNP_Device *card,
 439    struct DevBase *base)
 440 {
 441    struct ISAPNP_Identifier *id, *tail;
 442    BOOL compatible = FALSE;
 443    const UWORD *p;
 444
 445    id = (APTR)card->isapnpd_IDs.mlh_Head;
 446    tail = (APTR)&card->isapnpd_IDs.mlh_Tail;
 447
 448    while(id != tail)
 449    {
 450       vendor_id =
 451          ISAPNP_MAKE_ID(id->isapnpid_Vendor[0], id->isapnpid_Vendor[1],
 452          id->isapnpid_Vendor[2]);
 453       product_id = id->isapnpid_ProductID;
 454
 455       for(p = product_codes; p[0] != 0; p += 2)
 456       {
 457          if(p[0] == vendor_id && p[1] == product_id)
 458             compatible = TRUE;
 459       }
 460
 461       id = (APTR)id->isapnpid_MinNode.mln_Succ;
 462    }
 463
 464    return compatible;
 465 }
 466
 467
 468
 469 /****i* etherlink3.device/ByteInHook ***************************************
 470 *
 471 *   NAME
 472 *       ByteInHook
 473 *
 474 *   SYNOPSIS
 475 *       value = ByteInHook(context, offset)
 476 *
 477 *       UBYTE ByteInHook(struct BusContext *, ULONG);
 478 *
 479 ****************************************************************************
 480 *
 481 */
 482
 483 static UBYTE ByteInHook(struct BusContext *context, ULONG offset)
 484 {
 485    return BYTEIN(context->io_base + offset);
 486 }
 487
 488
 489
 490 /****i* etherlink3.device/LongInHook ***************************************
 491 *
 492 *   NAME
 493 *       LongInHook
 494 *
 495 *   SYNOPSIS
 496 *       value = LongInHook(context, offset)
 497 *
 498 *       ULONG LongInHook(struct BusContext *, ULONG);
 499 *
 500 ****************************************************************************
 501 *
 502 */
 503
 504 static ULONG LongInHook(struct BusContext *context, ULONG offset)
 505 {
 506    return LONGIN(context->io_base + offset);
 507 }
 508
 509
 510
 511 /****i* etherlink3.device/ByteOutHook **************************************
 512 *
 513 *   NAME
 514 *       ByteOutHook
 515 *
 516 *   SYNOPSIS
 517 *       ByteOutHook(context, offset, value)
 518 *
 519 *       VOID ByteOutHook(struct BusContext *, ULONG, UBYTE);
 520 *
 521 ****************************************************************************
 522 *
 523 */
 524
 525 static VOID ByteOutHook(struct BusContext *context, ULONG offset,
 526    UBYTE value)
 527 {
 528    BYTEOUT(context->io_base + offset, value);
 529
 530    return;
 531 }
 532
 533
 534
 535 /****i* etherlink3.device/WordOutHook **************************************
 536 *
 537 *   NAME
 538 *       WordOutHook
 539 *
 540 *   SYNOPSIS
 541 *       WordOutHook(context, offset, value)
 542 *
 543 *       VOID WordOutHook(struct BusContext *, ULONG, UWORD);
 544 *
 545 ****************************************************************************
 546 *
 547 */
 548
 549 static VOID WordOutHook(struct BusContext *context, ULONG offset,
 550    UWORD value)
 551 {
 552    WORDOUT(context->io_base + offset, value);
 553
 554    return;
 555 }
 556
 557
 558
 559 /****i* etherlink3.device/LongOutHook **************************************
 560 *
 561 *   NAME
 562 *       LongOutHook
 563 *
 564 *   SYNOPSIS
 565 *       LongOutHook(context, offset, value)
 566 *
 567 *       VOID LongOutHook(struct BusContext *, ULONG, ULONG);
 568 *
 569 ****************************************************************************
 570 *
 571 */
 572
 573 static VOID LongOutHook(struct BusContext *context, ULONG offset,
 574    ULONG value)
 575 {
 576    LONGOUT(context->io_base + offset, value);
 577
 578    return;
 579 }
 580
 581
 582
 583 /****i* etherlink3.device/LongsInHook **************************************
 584 *
 585 *   NAME
 586 *       LongsInHook
 587 *
 588 *   SYNOPSIS
 589 *       LongsInHook(context, offset, buffer, count)
 590 *
 591 *       VOID LongsInHook(struct BusContext *, ULONG, ULONG *, ULONG);
 592 *
 593 ****************************************************************************
 594 *
 595 */
 596
 597 static VOID LongsInHook(struct BusContext *context, ULONG offset,
 598    ULONG *buffer, ULONG count)
 599 {
 600    LONGSIN(context->io_base + offset, buffer, count);
 601
 602    return;
 603 }
 604
 605
 606
 607 /****i* etherlink3.device/LongsOutHook *************************************
 608 *
 609 *   NAME
 610 *       LongsOutHook
 611 *
 612 *   SYNOPSIS
 613 *       LongsOutHook(context, offset, buffer, count)
 614 *
 615 *       VOID LongsOutHook(struct BusContext *, ULONG, const ULONG *, ULONG);
 616 *
 617 ****************************************************************************
 618 *
 619 */
 620
 621 static VOID LongsOutHook(struct BusContext *context, ULONG offset,
 622    const ULONG *buffer, ULONG count)
 623 {
 624    LONGSOUT(context->io_base + offset, buffer, count);
 625
 626    return;
 627 }
 628
 629
 630
 631 /****i* etherlink3.device/BEWordOutHook ************************************
 632 *
 633 *   NAME
 634 *       BEWordOutHook
 635 *
 636 *   SYNOPSIS
 637 *       BEWordOutHook(context, offset, value)
 638 *
 639 *       VOID BEWordOutHook(struct BusContext *, ULONG, UWORD);
 640 *
 641 ****************************************************************************
 642 *
 643 */
 644
 645 static VOID BEWordOutHook(struct BusContext *context, ULONG offset,
 646    UWORD value)
 647 {
 648    BEWORDOUT(context->io_base + offset, value);
 649
 650    return;
 651 }
 652
 653
 654
 655 /****i* etherlink3.device/LEWordInHook *************************************
 656 *
 657 *   NAME
 658 *       LEWordInHook
 659 *
 660 *   SYNOPSIS
 661 *       value = LEWordInHook(context, offset)
 662 *
 663 *       UWORD LEWordInHook(struct BusContext *, ULONG);
 664 *
 665 ****************************************************************************
 666 *
 667 */
 668
 669 static UWORD LEWordInHook(struct BusContext *context, ULONG offset)
 670 {
 671    return LEWORDIN(context->io_base + offset);
 672 }
 673
 674
 675
 676 /****i* etherlink3.device/LELongInHook ***************************************
 677 *
 678 *   NAME
 679 *       LELongInHook
 680 *
 681 *   SYNOPSIS
 682 *       value = LELongInHook(context, offset)
 683 *
 684 *       ULONG LELongInHook(struct BusContext *, ULONG);
 685 *
 686 ****************************************************************************
 687 *
 688 */
 689
 690 static ULONG LELongInHook(struct BusContext *context, ULONG offset)
 691 {
 692    return LELONGIN(context->io_base + offset);
 693 }
 694
 695
 696
 697 /****i* etherlink3.device/LEWordOutHook ************************************
 698 *
 699 *   NAME
 700 *       LEWordOutHook
 701 *
 702 *   SYNOPSIS
 703 *       LEWordOutHook(context, offset, value)
 704 *
 705 *       VOID LEWordOutHook(struct BusContext *, ULONG, UWORD);
 706 *
 707 ****************************************************************************
 708 *
 709 */
 710
 711 static VOID LEWordOutHook(struct BusContext *context, ULONG offset,
 712    UWORD value)
 713 {
 714    LEWORDOUT(context->io_base + offset, value);
 715
 716    return;
 717 }
 718
 719
 720
 721 /****i* etherlink3.device/LELongOutHook ************************************
 722 *
 723 *   NAME
 724 *       LELongOutHook
 725 *
 726 *   SYNOPSIS
 727 *       LELongOutHook(context, offset, value)
 728 *
 729 *       VOID LELongOutHook(struct BusContext *, ULONG, ULONG);
 730 *
 731 ****************************************************************************
 732 *
 733 */
 734
 735 static VOID LELongOutHook(struct BusContext *context, ULONG offset,
 736    ULONG value)
 737 {
 738    LELONGOUT(context->io_base + offset, value);
 739
 740    return;
 741 }
 742
 743
 744