workbench/devs/networks/etherlink3/expansion.c

   1 /*
   2
   3 Copyright (C) 2004-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 <expansion/pci.h>
  25
  26 #include <proto/exec.h>
  27 #include <proto/expansion.h>
  28
  29 #include "device.h"
  30 #include "pci.h"
  31
  32 #include "pci_protos.h"
  33 #include "expansion_protos.h"
  34
  35
  36 /* Private prototypes */
  37
  38 static UBYTE ByteInHook(struct BusContext *context, ULONG offset);
  39 static ULONG LongInHook(struct BusContext *context, ULONG offset);
  40 static VOID ByteOutHook(struct BusContext *context, ULONG offset,
  41    UBYTE value);
  42 static VOID WordOutHook(struct BusContext *context, ULONG offset,
  43    UWORD value);
  44 static VOID LongOutHook(struct BusContext *context, ULONG offset,
  45    ULONG value);
  46 static VOID LongsInHook(struct BusContext *context, ULONG offset,
  47    ULONG *buffer, ULONG count);
  48 static VOID LongsOutHook(struct BusContext *context, ULONG offset,
  49    const ULONG *buffer, ULONG count);
  50 static VOID BEWordOutHook(struct BusContext *context, ULONG offset,
  51    UWORD value);
  52 static UWORD LEWordInHook(struct BusContext *context, ULONG offset);
  53 static ULONG LELongInHook(struct BusContext *context, ULONG offset);
  54 static VOID LEWordOutHook(struct BusContext *context, ULONG offset,
  55    UWORD value);
  56 static VOID LELongOutHook(struct BusContext *context, ULONG offset,
  57    ULONG value);
  58 static APTR AllocDMAMemHook(struct BusContext *context, UPINT size,
  59    UWORD alignment);
  60 static VOID FreeDMAMemHook(struct BusContext *context, APTR mem);
  61
  62
  63 IMPORT const UWORD product_codes[];
  64
  65
  66 static const struct TagItem unit_tags[] =
  67 {
  68    {IOTAG_ByteIn, (UPINT)ByteInHook},
  69    {IOTAG_LongIn, (UPINT)LongInHook},
  70    {IOTAG_ByteOut, (UPINT)ByteOutHook},
  71    {IOTAG_WordOut, (UPINT)WordOutHook},
  72    {IOTAG_LongOut, (UPINT)LongOutHook},
  73    {IOTAG_LongsIn, (UPINT)LongsInHook},
  74    {IOTAG_LongsOut, (UPINT)LongsOutHook},
  75    {IOTAG_BEWordOut, (UPINT)BEWordOutHook},
  76    {IOTAG_LEWordIn, (UPINT)LEWordInHook},
  77    {IOTAG_LELongIn, (UPINT)LELongInHook},
  78    {IOTAG_LEWordOut, (UPINT)LEWordOutHook},
  79    {IOTAG_LELongOut, (UPINT)LELongOutHook},
  80    {IOTAG_AllocDMAMem, (UPINT)AllocDMAMemHook},
  81    {IOTAG_FreeDMAMem, (UPINT)FreeDMAMemHook},
  82    {TAG_END, 0}
  83 };
  84
  85
  86 /****i* etherlink3.device/GetExpansionCount ********************************
  87 *
  88 *   NAME
  89 *       GetExpansionCount -- Get the number of compatible PCI Cards.
  90 *
  91 *   SYNOPSIS
  92 *       count = GetExpansionCount()
  93 *
  94 *       ULONG GetExpansionCount();
  95 *
  96 ****************************************************************************
  97 *
  98 */
  99
 100 ULONG GetExpansionCount(struct DevBase *base)
 101 {
 102    ULONG count = 0;
 103    struct PCIDevice *card;
 104
 105    if(base->i_pci != NULL)
 106    {
 107       while((card =
 108          base->i_pci->FindDeviceTags(FDT_CandidateList, product_codes,
 109          FDT_Index, count, TAG_END)) != NULL)
 110       {
 111          base->i_pci->FreeDevice(card);
 112          count++;
 113       }
 114    }
 115
 116    return count;
 117 }
 118
 119
 120
 121 /****i* etherlink3.device/AllocExpansionCard *******************************
 122 *
 123 *   NAME
 124 *       AllocExpansionCard -- Take control of a card.
 125 *
 126 *   SYNOPSIS
 127 *       context = AllocExpansionCard(index)
 128 *
 129 *       struct BusContext *AllocExpansionCard(ULONG);
 130 *
 131 ****************************************************************************
 132 *
 133 */
 134
 135 struct BusContext *AllocExpansionCard(ULONG index, struct DevBase *base)
 136 {
 137    BOOL success = TRUE;
 138    struct BusContext *context;
 139    struct PCIDevice *card = NULL;
 140    struct PCIResourceRange *io_range = NULL;
 141    UWORD product_id;
 142
 143    /* Find a compatible card */
 144
 145    context = AllocMem(sizeof(struct BusContext), MEMF_PUBLIC | MEMF_CLEAR);
 146    if(context == NULL)
 147       success = FALSE;
 148
 149    if(success)
 150    {
 151       context->card = card =
 152          base->i_pci->FindDeviceTags(FDT_CandidateList, product_codes,
 153          FDT_Index, index, TAG_END);
 154       product_id = card->ReadConfigWord(PCI_DEVICE_ID);
 155       if(card == NULL)
 156          success = FALSE;
 157    }
 158
 159    /* Lock card */
 160
 161    if(success)
 162       success = card->Lock(PCI_LOCK_EXCLUSIVE);
 163
 164    /* Get base address and generation */
 165
 166    if(success)
 167    {
 168       context->have_card = TRUE;
 169       card->SetEndian(PCI_MODE_LITTLE_ENDIAN);
 170       io_range = card->GetResourceRange(BAR_NO);
 171       context->io_base = io_range->BaseAddress;
 172       card->FreeResourceRange(io_range);
 173       context->unit_tags = unit_tags;
 174       context->generation = GetGeneration(product_id, base);
 175    }
 176
 177    if(!success)
 178    {
 179       FreeExpansionCard(context, base);
 180       context = NULL;
 181    }
 182
 183    return context;
 184 }
 185
 186
 187
 188 /****i* etherlink3.device/FreeExpansionCard ********************************
 189 *
 190 *   NAME
 191 *       FreeExpansionCard -- Release a card.
 192 *
 193 *   SYNOPSIS
 194 *       FreeExpansionCard(context)
 195 *
 196 *       VOID FreeExpansionCard(struct BusContext *);
 197 *
 198 ****************************************************************************
 199 *
 200 */
 201
 202 VOID FreeExpansionCard(struct BusContext *context, struct DevBase *base)
 203 {
 204    struct PCIDevice *card;
 205
 206    if(context != NULL)
 207    {
 208       card = context->card;
 209       if(card != NULL)
 210       {
 211          if(context->have_card)
 212             card->Unlock();
 213          base->i_pci->FreeDevice(card);
 214          FreeMem(context, sizeof(struct BusContext));
 215       }
 216    }
 217
 218    return;
 219 }
 220
 221
 222
 223 /****i* etherlink3.device/AddExpansionIntServer ****************************
 224 *
 225 *   NAME
 226 *       AddExpansionIntServer
 227 *
 228 *   SYNOPSIS
 229 *       success = AddExpansionIntServer(card, interrupt)
 230 *
 231 *       BOOL AddExpansionIntServer(APTR, struct Interrupt *);
 232 *
 233 ****************************************************************************
 234 *
 235 */
 236
 237 BOOL AddExpansionIntServer(APTR card, struct Interrupt *interrupt,
 238    struct DevBase *base)
 239 {
 240    return AddIntServer(((struct PCIDevice *)card)->MapInterrupt(),
 241       interrupt);
 242 }
 243
 244
 245
 246 /****i* etherlink3.device/RemExpansionIntServer ****************************
 247 *
 248 *   NAME
 249 *       RemExpansionIntServer
 250 *
 251 *   SYNOPSIS
 252 *       RemExpansionIntServer(card, interrupt)
 253 *
 254 *       VOID RemExpansionIntServer(APTR, struct Interrupt *);
 255 *
 256 ****************************************************************************
 257 *
 258 */
 259
 260 VOID RemExpansionIntServer(APTR card, struct Interrupt *interrupt,
 261    struct DevBase *base)
 262 {
 263    RemIntServer(((struct PCIDevice *)card)->MapInterrupt(), interrupt);
 264
 265    return;
 266 }
 267
 268
 269
 270 /****i* etherlink3.device/ByteInHook ***************************************
 271 *
 272 *   NAME
 273 *       ByteInHook
 274 *
 275 *   SYNOPSIS
 276 *       value = ByteInHook(context, offset)
 277 *
 278 *       UBYTE ByteInHook(struct BusContext *, ULONG);
 279 *
 280 ****************************************************************************
 281 *
 282 */
 283
 284 static UBYTE ByteInHook(struct BusContext *context, ULONG offset)
 285 {
 286    struct PCIDevice *card;
 287
 288    card = context->card;
 289    return card->InByte(context->io_base + offset);
 290 }
 291
 292
 293
 294 /****i* etherlink3.device/LongInHook ***************************************
 295 *
 296 *   NAME
 297 *       LongInHook
 298 *
 299 *   SYNOPSIS
 300 *       value = LongInHook(context, offset)
 301 *
 302 *       ULONG LongInHook(struct BusContext *, ULONG);
 303 *
 304 ****************************************************************************
 305 *
 306 */
 307
 308 static ULONG LongInHook(struct BusContext *context, ULONG offset)
 309 {
 310    struct PCIDevice *card;
 311
 312    card = context->card;
 313    return card->InLong(context->io_base + offset);
 314 }
 315
 316
 317
 318 /****i* etherlink3.device/ByteOutHook **************************************
 319 *
 320 *   NAME
 321 *       ByteOutHook
 322 *
 323 *   SYNOPSIS
 324 *       ByteOutHook(context, offset, value)
 325 *
 326 *       VOID ByteOutHook(struct BusContext *, ULONG, UBYTE);
 327 *
 328 ****************************************************************************
 329 *
 330 */
 331
 332 static VOID ByteOutHook(struct BusContext *context, ULONG offset,
 333    UBYTE value)
 334 {
 335    struct PCIDevice *card;
 336
 337    card = context->card;
 338    card->OutByte(context->io_base + offset, value);
 339
 340    return;
 341 }
 342
 343
 344
 345 /****i* etherlink3.device/WordOutHook **************************************
 346 *
 347 *   NAME
 348 *       WordOutHook
 349 *
 350 *   SYNOPSIS
 351 *       WordOutHook(context, offset, value)
 352 *
 353 *       VOID WordOutHook(struct BusContext *, ULONG, UWORD);
 354 *
 355 ****************************************************************************
 356 *
 357 */
 358
 359 static VOID WordOutHook(struct BusContext *context, ULONG offset,
 360    UWORD value)
 361 {
 362    struct PCIDevice *card;
 363
 364    card = context->card;
 365    card->OutWord(context->io_base + offset, value);
 366
 367    return;
 368 }
 369
 370
 371
 372 /****i* etherlink3.device/LongOutHook **************************************
 373 *
 374 *   NAME
 375 *       LongOutHook
 376 *
 377 *   SYNOPSIS
 378 *       LongOutHook(context, offset, value)
 379 *
 380 *       VOID LongOutHook(struct BusContext *, ULONG, ULONG);
 381 *
 382 ****************************************************************************
 383 *
 384 */
 385
 386 static VOID LongOutHook(struct BusContext *context, ULONG offset,
 387    ULONG value)
 388 {
 389    struct PCIDevice *card;
 390
 391    card = context->card;
 392    card->OutLong(context->io_base + offset, value);
 393
 394    return;
 395 }
 396
 397
 398
 399 /****i* etherlink3.device/LongsInHook **************************************
 400 *
 401 *   NAME
 402 *       LongsInHook
 403 *
 404 *   SYNOPSIS
 405 *       LongsInHook(context, offset, buffer, count)
 406 *
 407 *       VOID LongsInHook(struct BusContext *, ULONG, ULONG *, ULONG);
 408 *
 409 ****************************************************************************
 410 *
 411 */
 412
 413 static VOID LongsInHook(struct BusContext *context, ULONG offset,
 414    ULONG *buffer, ULONG count)
 415 {
 416    struct PCIDevice *card;
 417
 418    card = context->card;
 419    while(count-- > 0)
 420       *buffer++ = card->InLong(context->io_base + offset);
 421
 422    return;
 423 }
 424
 425
 426
 427 /****i* etherlink3.device/LongsOutHook *************************************
 428 *
 429 *   NAME
 430 *       LongsOutHook
 431 *
 432 *   SYNOPSIS
 433 *       LongsOutHook(context, offset, buffer, count)
 434 *
 435 *       VOID LongsOutHook(struct BusContext *, ULONG, const ULONG *, ULONG);
 436 *
 437 ****************************************************************************
 438 *
 439 */
 440
 441 static VOID LongsOutHook(struct BusContext *context, ULONG offset,
 442    const ULONG *buffer, ULONG count)
 443 {
 444    struct PCIDevice *card;
 445
 446    card = context->card;
 447    while(count-- > 0)
 448       card->OutLong(context->io_base + offset, *buffer++);
 449
 450    return;
 451 }
 452
 453
 454
 455 /****i* etherlink3.device/BEWordOutHook ************************************
 456 *
 457 *   NAME
 458 *       BEWordOutHook
 459 *
 460 *   SYNOPSIS
 461 *       BEWordOutHook(context, offset, value)
 462 *
 463 *       VOID BEWordOutHook(struct BusContext *, ULONG, UWORD);
 464 *
 465 ****************************************************************************
 466 *
 467 */
 468
 469 static VOID BEWordOutHook(struct BusContext *context, ULONG offset,
 470    UWORD value)
 471 {
 472    struct PCIDevice *card;
 473
 474    card = context->card;
 475    card->OutWord(context->io_base + offset, MakeBEWord(value));
 476
 477    return;
 478 }
 479
 480
 481
 482 /****i* etherlink3.device/LEWordInHook *************************************
 483 *
 484 *   NAME
 485 *       LEWordInHook
 486 *
 487 *   SYNOPSIS
 488 *       value = LEWordInHook(context, offset)
 489 *
 490 *       UWORD LEWordInHook(struct BusContext *, ULONG);
 491 *
 492 ****************************************************************************
 493 *
 494 */
 495
 496 static UWORD LEWordInHook(struct BusContext *context, ULONG offset)
 497 {
 498    struct PCIDevice *card;
 499
 500    card = context->card;
 501    return LEWord(card->InWord(context->io_base + offset));
 502 }
 503
 504
 505
 506 /****i* etherlink3.device/LELongInHook *************************************
 507 *
 508 *   NAME
 509 *       LELongInHook
 510 *
 511 *   SYNOPSIS
 512 *       value = LELongInHook(context, offset)
 513 *
 514 *       ULONG LELongInHook(struct BusContext *, ULONG);
 515 *
 516 ****************************************************************************
 517 *
 518 */
 519
 520 static ULONG LELongInHook(struct BusContext *context, ULONG offset)
 521 {
 522    struct PCIDevice *card;
 523
 524    card = context->card;
 525    return LELong(card->InLong(context->io_base + offset));
 526 }
 527
 528
 529
 530 /****i* etherlink3.device/LEWordOutHook ************************************
 531 *
 532 *   NAME
 533 *       LEWordOutHook
 534 *
 535 *   SYNOPSIS
 536 *       LEWordOutHook(context, offset, value)
 537 *
 538 *       VOID LEWordOutHook(struct BusContext *, ULONG, UWORD);
 539 *
 540 ****************************************************************************
 541 *
 542 */
 543
 544 static VOID LEWordOutHook(struct BusContext *context, ULONG offset,
 545    UWORD value)
 546 {
 547    struct PCIDevice *card;
 548
 549    card = context->card;
 550    card->OutWord(context->io_base + offset, MakeLEWord(value));
 551
 552    return;
 553 }
 554
 555
 556
 557 /****i* etherlink3.device/LELongOutHook ************************************
 558 *
 559 *   NAME
 560 *       LELongOutHook
 561 *
 562 *   SYNOPSIS
 563 *       LELongOutHook(context, offset, value)
 564 *
 565 *       VOID LELongOutHook(struct BusContext *, ULONG, ULONG);
 566 *
 567 ****************************************************************************
 568 *
 569 */
 570
 571 static VOID LELongOutHook(struct BusContext *context, ULONG offset,
 572    ULONG value)
 573 {
 574    struct PCIDevice *card;
 575
 576    card = context->card;
 577    card->OutLong(context->io_base + offset, MakeLELong(value));
 578
 579    return;
 580 }
 581
 582
 583
 584 /****i* etherlink3.device/AllocDMAMemHook **********************************
 585 *
 586 *   NAME
 587 *       AllocDMAMemHook
 588 *
 589 *   SYNOPSIS
 590 *       mem = AllocDMAMemHook(context, size, alignment)
 591 *
 592 *       APTR AllocDMAMemHook(struct BusContext *, UPINT, UWORD);
 593 *
 594 ****************************************************************************
 595 *
 596 * Alignment currently must be minimum of 8 bytes.
 597 *
 598 */
 599
 600 static APTR AllocDMAMemHook(struct BusContext *context, UPINT size,
 601    UWORD alignment)
 602 {
 603    struct DevBase *base;
 604    APTR mem = NULL, original_mem;
 605
 606    base = context->device;
 607    size += 2 * sizeof(APTR) + alignment;
 608    original_mem = AllocMem(size, MEMF_PUBLIC);
 609    if(original_mem != NULL)
 610    {
 611       mem = (APTR)((UPINT)(original_mem + 2 * sizeof(APTR) + alignment - 1)
 612          & ~(alignment - 1));
 613       *((APTR *)mem - 1) = original_mem;
 614       *((UPINT *)mem - 2) = size;
 615    }
 616
 617    return mem;
 618 }
 619
 620
 621
 622 /****i* etherlink3.device/FreeDMAMemHook ***********************************
 623 *
 624 *   NAME
 625 *       FreeDMAMemHook
 626 *
 627 *   SYNOPSIS
 628 *       FreeDMAMemHook(context, mem)
 629 *
 630 *       VOID FreeDMAMemHook(struct BusContext *, APTR);
 631 *
 632 ****************************************************************************
 633 *
 634 */
 635
 636 static VOID FreeDMAMemHook(struct BusContext *context, APTR mem)
 637 {
 638    struct DevBase *base;
 639
 640    base = context->device;
 641    if(mem != NULL)
 642          FreeMem(*((APTR *)mem - 1), *((UPINT *)mem - 2));
 643
 644    return;
 645 }
 646
 647
 648