workbench/devs/networks/etherlink3/isa.c

   1 /*
   2
   3 Copyright (C) 2000-2006 Neil Cafferkey
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful, but
  11 WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13 General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18 MA 02111-1307, USA.
  19
  20 */
  21
  22
  23 #include <exec/types.h>
  24 /*#include <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 *       unit = AllocCard()
 336 *
 337 *       struct BusContext *AllocCard();
 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
 396 *
 397 ****************************************************************************
 398 *
 399 */
 400
 401 static VOID FreeCard(struct BusContext *context, struct DevBase *base)
 402 {
 403    struct ISAPNP_Device *card = NULL;
 404
 405    if(context != NULL)
 406    {
 407       /* Unlock card */
 408
 409       ISAPNP_UnlockDevices(context->lock);
 410
 411       FreeMem(context, sizeof(struct BusContext));
 412    }
 413
 414    return;
 415 }
 416
 417
 418
 419 /****i* etherlink3.device/IsCardCompatible *********************************
 420 *
 421 *   NAME
 422 *       IsCardCompatible
 423 *
 424 *   SYNOPSIS
 425 *       compatible = IsCardCompatible(card)
 426 *
 427 *       BOOL IsCardCompatible(struct ISAPNP_Device *);
 428 *
 429 ****************************************************************************
 430 *
 431 */
 432
 433 static BOOL IsCardCompatible(struct ISAPNP_Device *card,
 434    struct DevBase *base)
 435 {
 436    struct ISAPNP_Identifier *id, *tail;
 437    BOOL compatible = FALSE;
 438    const UWORD *p;
 439
 440    id = (APTR)card->isapnpd_IDs.mlh_Head;
 441    tail = (APTR)&card->isapnpd_IDs.mlh_Tail;
 442
 443    while(id != tail)
 444    {
 445       vendor_id =
 446          ISAPNP_MAKE_ID(id->isapnpid_Vendor[0], id->isapnpid_Vendor[1],
 447          id->isapnpid_Vendor[2]);
 448       product_id = id->isapnpid_ProductID;
 449
 450       for(p = product_codes; p[0] != 0; p += 2)
 451       {
 452          if(p[0] == vendor_id && p[1] == product_id)
 453             compatible = TRUE;
 454       }
 455
 456       id = (APTR)id->isapnpid_MinNode.mln_Succ;
 457    }
 458
 459    return compatible;
 460 }
 461
 462
 463
 464 /****i* etherlink3.device/ByteInHook ***************************************
 465 *
 466 *   NAME
 467 *       ByteInHook
 468 *
 469 *   SYNOPSIS
 470 *       value = ByteInHook(context, offset)
 471 *
 472 *       UBYTE ByteInHook(struct BusContext *, ULONG);
 473 *
 474 ****************************************************************************
 475 *
 476 */
 477
 478 static UBYTE ByteInHook(struct BusContext *context, ULONG offset)
 479 {
 480    return BYTEIN(context->io_base + offset);
 481 }
 482
 483
 484
 485 /****i* etherlink3.device/LongInHook ***************************************
 486 *
 487 *   NAME
 488 *       LongInHook
 489 *
 490 *   SYNOPSIS
 491 *       value = LongInHook(context, offset)
 492 *
 493 *       ULONG LongInHook(struct BusContext *, ULONG);
 494 *
 495 ****************************************************************************
 496 *
 497 */
 498
 499 static ULONG LongInHook(struct BusContext *context, ULONG offset)
 500 {
 501    return LONGIN(context->io_base + offset);
 502 }
 503
 504
 505
 506 /****i* etherlink3.device/ByteOutHook **************************************
 507 *
 508 *   NAME
 509 *       ByteOutHook
 510 *
 511 *   SYNOPSIS
 512 *       ByteOutHook(context, offset, value)
 513 *
 514 *       VOID ByteOutHook(struct BusContext *, ULONG, UBYTE);
 515 *
 516 ****************************************************************************
 517 *
 518 */
 519
 520 static VOID ByteOutHook(struct BusContext *context, ULONG offset,
 521    UBYTE value)
 522 {
 523    BYTEOUT(context->io_base + offset, value);
 524
 525    return;
 526 }
 527
 528
 529
 530 /****i* etherlink3.device/WordOutHook **************************************
 531 *
 532 *   NAME
 533 *       WordOutHook
 534 *
 535 *   SYNOPSIS
 536 *       WordOutHook(context, offset, value)
 537 *
 538 *       VOID WordOutHook(struct BusContext *, ULONG, UWORD);
 539 *
 540 ****************************************************************************
 541 *
 542 */
 543
 544 static VOID WordOutHook(struct BusContext *context, ULONG offset,
 545    UWORD value)
 546 {
 547    WORDOUT(context->io_base + offset, value);
 548
 549    return;
 550 }
 551
 552
 553
 554 /****i* etherlink3.device/LongOutHook **************************************
 555 *
 556 *   NAME
 557 *       LongOutHook
 558 *
 559 *   SYNOPSIS
 560 *       LongOutHook(context, offset, value)
 561 *
 562 *       VOID LongOutHook(struct BusContext *, ULONG, ULONG);
 563 *
 564 ****************************************************************************
 565 *
 566 */
 567
 568 static VOID LongOutHook(struct BusContext *context, ULONG offset,
 569    ULONG value)
 570 {
 571    LONGOUT(context->io_base + offset, value);
 572
 573    return;
 574 }
 575
 576
 577
 578 /****i* etherlink3.device/LongsInHook **************************************
 579 *
 580 *   NAME
 581 *       LongsInHook
 582 *
 583 *   SYNOPSIS
 584 *       LongsInHook(context, offset, buffer, count)
 585 *
 586 *       VOID LongsInHook(struct BusContext *, ULONG, ULONG *, ULONG);
 587 *
 588 ****************************************************************************
 589 *
 590 */
 591
 592 static VOID LongsInHook(struct BusContext *context, ULONG offset,
 593    ULONG *buffer, ULONG count)
 594 {
 595    LONGSIN(context->io_base + offset, buffer, count);
 596
 597    return;
 598 }
 599
 600
 601
 602 /****i* etherlink3.device/LongsOutHook *************************************
 603 *
 604 *   NAME
 605 *       LongsOutHook
 606 *
 607 *   SYNOPSIS
 608 *       LongsOutHook(context, offset, buffer, count)
 609 *
 610 *       VOID LongsOutHook(struct BusContext *, ULONG, const ULONG *, ULONG);
 611 *
 612 ****************************************************************************
 613 *
 614 */
 615
 616 static VOID LongsOutHook(struct BusContext *context, ULONG offset,
 617    const ULONG *buffer, ULONG count)
 618 {
 619    LONGSOUT(context->io_base + offset, buffer, count);
 620
 621    return;
 622 }
 623
 624
 625
 626 /****i* etherlink3.device/BEWordOutHook ************************************
 627 *
 628 *   NAME
 629 *       BEWordOutHook
 630 *
 631 *   SYNOPSIS
 632 *       BEWordOutHook(context, offset, value)
 633 *
 634 *       VOID BEWordOutHook(struct BusContext *, ULONG, UWORD);
 635 *
 636 ****************************************************************************
 637 *
 638 */
 639
 640 static VOID BEWordOutHook(struct BusContext *context, ULONG offset,
 641    UWORD value)
 642 {
 643    BEWORDOUT(context->io_base + offset, value);
 644
 645    return;
 646 }
 647
 648
 649
 650 /****i* etherlink3.device/LEWordInHook *************************************
 651 *
 652 *   NAME
 653 *       LEWordInHook
 654 *
 655 *   SYNOPSIS
 656 *       value = LEWordInHook(context, offset)
 657 *
 658 *       UWORD LEWordInHook(struct BusContext *, ULONG);
 659 *
 660 ****************************************************************************
 661 *
 662 */
 663
 664 static UWORD LEWordInHook(struct BusContext *context, ULONG offset)
 665 {
 666    return LEWORDIN(context->io_base + offset);
 667 }
 668
 669
 670
 671 /****i* etherlink3.device/LELongInHook ***************************************
 672 *
 673 *   NAME
 674 *       LELongInHook
 675 *
 676 *   SYNOPSIS
 677 *       value = LELongInHook(context, offset)
 678 *
 679 *       ULONG LELongInHook(struct BusContext *, ULONG);
 680 *
 681 ****************************************************************************
 682 *
 683 */
 684
 685 static ULONG LELongInHook(struct BusContext *context, ULONG offset)
 686 {
 687    return LELONGIN(context->io_base + offset);
 688 }
 689
 690
 691
 692 /****i* etherlink3.device/LEWordOutHook ************************************
 693 *
 694 *   NAME
 695 *       LEWordOutHook
 696 *
 697 *   SYNOPSIS
 698 *       LEWordOutHook(context, offset, value)
 699 *
 700 *       VOID LEWordOutHook(struct BusContext *, ULONG, UWORD);
 701 *
 702 ****************************************************************************
 703 *
 704 */
 705
 706 static VOID LEWordOutHook(struct BusContext *context, ULONG offset,
 707    UWORD value)
 708 {
 709    LEWORDOUT(context->io_base + offset, value);
 710
 711    return;
 712 }
 713
 714
 715
 716 /****i* etherlink3.device/LELongOutHook ************************************
 717 *
 718 *   NAME
 719 *       LELongOutHook
 720 *
 721 *   SYNOPSIS
 722 *       LELongOutHook(context, offset, value)
 723 *
 724 *       VOID LELongOutHook(struct BusContext *, ULONG, ULONG);
 725 *
 726 ****************************************************************************
 727 *
 728 */
 729
 730 static VOID LELongOutHook(struct BusContext *context, ULONG offset,
 731    ULONG value)
 732 {
 733    LELONGOUT(context->io_base + offset, value);
 734
 735    return;
 736 }
 737
 738
 739