workbench/devs/networks/rhine/pci.c

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