workbench/devs/networks/prism2/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
  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 "device_protos.h"
  34 #include "prometheus_protos.h"
  35 #include "powerpci_protos.h"
  36 #include "cybpci_protos.h"
  37 #include "expansion_protos.h"
  38 #include "openpci_protos.h"
  39 #include "unit_protos.h"
  40
  41
  42 /* Private prototypes */
  43
  44 static struct DevUnit *FindPCIUnit(ULONG index, struct DevBase *base);
  45 static struct DevUnit *CreatePCIUnit(ULONG index, struct DevBase *base);
  46 static struct BusContext *AllocCard(ULONG index, struct DevBase *base);
  47 static VOID FreeCard(struct BusContext *context, struct DevBase *base);
  48 static BOOL AddPCIIntServer(APTR card, struct Interrupt *interrupt,
  49    struct DevBase *base);
  50 static VOID RemPCIIntServer(APTR card, struct Interrupt *interrupt,
  51    struct DevBase *base);
  52 BOOL IsCardCompatible(UWORD vendor_id, UWORD product_id,
  53    struct DevBase *base);
  54 static VOID WordsInHook(struct BusContext *context, ULONG offset,
  55    UWORD *buffer, ULONG count);
  56 static VOID WordsOutHook(struct BusContext *context, ULONG offset,
  57    const UWORD *buffer, ULONG count);
  58 static VOID BEWordOutHook(struct BusContext *context, ULONG offset,
  59    UWORD value);
  60 static UWORD LEWordInHook(struct BusContext *context, ULONG offset);
  61 static VOID LEWordOutHook(struct BusContext *context, ULONG offset,
  62    UWORD value);
  63 static VOID WordsInIOHook(struct BusContext *context, ULONG offset,
  64    UWORD *buffer, ULONG count);
  65 static VOID WordsOutIOHook(struct BusContext *context, ULONG offset,
  66    const UWORD *buffer, ULONG count);
  67 static VOID BEWordOutIOHook(struct BusContext *context, ULONG offset,
  68    UWORD value);
  69 static UWORD LEWordInIOHook(struct BusContext *context, ULONG offset);
  70 static VOID LEWordOutIOHook(struct BusContext *context, ULONG offset,
  71    UWORD value);
  72
  73
  74 const UWORD product_codes[] =
  75 {
  76    0x10b7, 0x7770,
  77    0x111a, 0x1023,
  78    0x1260, 0x3872,
  79    0x1260, 0x3873,
  80    0x1385, 0x4100,
  81    0x15e8, 0x0130,
  82    0x15e8, 0x0131,
  83    0x1638, 0x1100,
  84    0x16ab, 0x1100,
  85    0x16ab, 0x1101,
  86    0x16ab, 0x1102,
  87    0x16ec, 0x3685,
  88    0xec80, 0xec00,
  89    0xffff, 0xffff
  90 };
  91
  92
  93 static struct TagItem unit_tags[] =
  94 {
  95    {IOTAG_WordsIn, (UPINT)WordsInHook},
  96    {IOTAG_WordsOut, (UPINT)WordsOutHook},
  97    {IOTAG_BEWordOut, (UPINT)BEWordOutHook},
  98    {IOTAG_LEWordIn, (UPINT)LEWordInHook},
  99    {IOTAG_LEWordOut, (UPINT)LEWordOutHook},
 100    {TAG_END, 0}
 101 };
 102
 103
 104 static struct TagItem bridge_unit_tags[] =
 105 {
 106    {IOTAG_WordsIn, (UPINT)WordsInIOHook},
 107    {IOTAG_WordsOut, (UPINT)WordsOutIOHook},
 108    {IOTAG_BEWordOut, (UPINT)BEWordOutIOHook},
 109    {IOTAG_LEWordIn, (UPINT)LEWordInIOHook},
 110    {IOTAG_LEWordOut, (UPINT)LEWordOutIOHook},
 111    {TAG_END, 0}
 112 };
 113
 114
 115 /****i* prism2.device/GetPCICount ******************************************
 116 *
 117 *   NAME
 118 *       GetPCICount -- Get the number of compatible PCI Cards.
 119 *
 120 *   SYNOPSIS
 121 *       count = GetPCICount()
 122 *
 123 *       ULONG GetPCICount();
 124 *
 125 ****************************************************************************
 126 *
 127 */
 128
 129 ULONG GetPCICount(struct DevBase *base)
 130 {
 131    ULONG count = 0;
 132
 133 #if !(defined(__MORPHOS__) || defined(__amigaos4__))
 134    if(base->prometheus_base != NULL)
 135       count = GetPrometheusCount(base);
 136 #endif
 137 #if defined(__mc68000) && !defined(__AROS__)
 138    if(base->powerpci_base != NULL)
 139       count = GetPowerPCICount(base);
 140    if(base->cybpci_base != NULL)
 141       count = GetCybPCICount(base);
 142 #endif
 143 #ifdef __amigaos4__
 144    if(base->expansion_base != NULL)
 145       count = GetExpansionCount(base);
 146 #endif
 147 #ifdef __MORPHOS__
 148    if(base->openpci_base != NULL)
 149       count = GetOpenPCICount(base);
 150 #endif
 151
 152    return count;
 153 }
 154
 155
 156
 157 /****i* prism2.device/GetPCIUnit *******************************************
 158 *
 159 *   NAME
 160 *       GetPCIUnit -- Get a unit by number.
 161 *
 162 *   SYNOPSIS
 163 *       unit = GetPCIUnit(index)
 164 *
 165 *       struct DevUnit *GetPCIUnit(ULONG);
 166 *
 167 ****************************************************************************
 168 *
 169 */
 170
 171 struct DevUnit *GetPCIUnit(ULONG index, struct DevBase *base)
 172 {
 173    struct DevUnit *unit;
 174
 175    unit = FindPCIUnit(index, base);
 176
 177    if(unit == NULL)
 178    {
 179       unit = CreatePCIUnit(index, base);
 180       if(unit != NULL)
 181       {
 182          AddTail((APTR)&base->pci_units, (APTR)unit);
 183       }
 184    }
 185
 186    return unit;
 187 }
 188
 189
 190
 191 /****i* prism2.device/FindPCIUnit ******************************************
 192 *
 193 *   NAME
 194 *       FindPCIUnit -- Find a unit by number.
 195 *
 196 *   SYNOPSIS
 197 *       unit = FindPCIUnit(index)
 198 *
 199 *       struct DevUnit *FindPCIUnit(ULONG);
 200 *
 201 ****************************************************************************
 202 *
 203 */
 204
 205 static struct DevUnit *FindPCIUnit(ULONG index, struct DevBase *base)
 206 {
 207    struct DevUnit *unit, *tail;
 208    BOOL found = FALSE;
 209
 210    unit = (APTR)base->pci_units.mlh_Head;
 211    tail = (APTR)&base->pci_units.mlh_Tail;
 212
 213    while(unit != tail && !found)
 214    {
 215       if(unit->index == index)
 216          found = TRUE;
 217       else
 218          unit = (APTR)unit->node.mln_Succ;
 219    }
 220
 221    if(!found)
 222       unit = NULL;
 223
 224    return unit;
 225 }
 226
 227
 228
 229 /****i* prism2.device/CreatePCIUnit ****************************************
 230 *
 231 *   NAME
 232 *       CreatePCIUnit -- Create a unit.
 233 *
 234 *   SYNOPSIS
 235 *       unit = CreatePCIUnit(index)
 236 *
 237 *       struct DevUnit *CreatePCIUnit(ULONG);
 238 *
 239 *   FUNCTION
 240 *       Creates a PCI new unit.
 241 *
 242 ****************************************************************************
 243 *
 244 */
 245
 246 static struct DevUnit *CreatePCIUnit(ULONG index, struct DevBase *base)
 247 {
 248    BOOL success = TRUE;
 249    struct BusContext *context;
 250    struct DevUnit *unit = NULL;
 251
 252    context = AllocCard(index, base);
 253    if(context == NULL)
 254       success = FALSE;
 255
 256    if(success)
 257    {
 258       if(context->unit_tags == NULL)
 259       {
 260          if(context->bus_type == PCI_BUS)
 261             context->unit_tags = unit_tags;
 262          else
 263             context->unit_tags = bridge_unit_tags;
 264       }
 265
 266       context->unit = unit =
 267          CreateUnit(index, context, context->unit_tags, context->bus_type,
 268             base);
 269       if(unit == NULL)
 270          success = FALSE;
 271    }
 272
 273    /* Add interrupt */
 274
 275    if(success)
 276    {
 277       if(!(WrapInt(&unit->status_int, base)
 278          && WrapInt(&unit->rx_int, base)
 279          && WrapInt(&unit->tx_int, base)
 280          && WrapInt(&unit->info_int, base)
 281          && WrapInt(&unit->reset_handler, base)))
 282          success = FALSE;
 283    }
 284
 285    /* Add hardware interrupt and reset handler */
 286
 287    if(success)
 288    {
 289       if(AddPCIIntServer(context->card, &unit->status_int, base))
 290          unit->flags |= UNITF_INTADDED;
 291       else
 292          success = FALSE;
 293
 294 #if defined(__amigaos4__) || defined(__AROS__)
 295       if(AddResetCallback(&unit->reset_handler))
 296          unit->flags |= UNITF_RESETADDED;
 297       else
 298          success = FALSE;
 299 #endif
 300    }
 301
 302    if(!success)
 303    {
 304       if(context != NULL)
 305       {
 306          DeleteUnit(context->unit, base);
 307          FreeCard(context, base);
 308       }
 309       unit = NULL;
 310    }
 311
 312    return unit;
 313 }
 314
 315
 316
 317 /****i* prism2.device/DeletePCIUnit ****************************************
 318 *
 319 *   NAME
 320 *       DeletePCIUnit -- Delete a unit.
 321 *
 322 *   SYNOPSIS
 323 *       DeletePCIUnit(unit)
 324 *
 325 *       VOID DeletePCIUnit(struct DevUnit *);
 326 *
 327 *   FUNCTION
 328 *       Deletes a unit.
 329 *
 330 *   INPUTS
 331 *       unit - Device unit (can be NULL).
 332 *
 333 *   RESULT
 334 *       None.
 335 *
 336 ****************************************************************************
 337 *
 338 */
 339
 340 VOID DeletePCIUnit(struct DevUnit *unit, struct DevBase *base)
 341 {
 342    struct BusContext *context;
 343
 344    if(unit != NULL)
 345    {
 346       context = unit->card;
 347 #if defined(__amigaos4__) || defined(__AROS__)
 348       if((unit->flags & UNITF_RESETADDED) != 0)
 349          RemResetCallback(&unit->reset_handler);
 350 #endif
 351       if((unit->flags & UNITF_INTADDED) != 0)
 352          RemPCIIntServer(context->card, &unit->status_int, base);
 353       UnwrapInt(&unit->reset_handler, base);
 354       UnwrapInt(&unit->info_int, base);
 355       UnwrapInt(&unit->tx_int, base);
 356       UnwrapInt(&unit->rx_int, base);
 357       UnwrapInt(&unit->status_int, base);
 358       DeleteUnit(unit, base);
 359       FreeCard(context, base);
 360    }
 361
 362    return;
 363 }
 364
 365
 366
 367 /****i* prism2.device/AllocCard ********************************************
 368 *
 369 *   NAME
 370 *       AllocCard -- Get card from system.
 371 *
 372 *   SYNOPSIS
 373 *       context = AllocCard(index)
 374 *
 375 *       struct BusContext *AllocCard(ULONG);
 376 *
 377 ****************************************************************************
 378 *
 379 */
 380
 381 static struct BusContext *AllocCard(ULONG index, struct DevBase *base)
 382 {
 383    struct BusContext *context;
 384
 385 #if !(defined(__MORPHOS__) || defined(__amigaos4__))
 386    if(base->prometheus_base != NULL)
 387       context = AllocPrometheusCard(index, base);
 388 #endif
 389 #if defined(__mc68000) && !defined(__AROS__)
 390    if(base->powerpci_base != NULL)
 391       context = AllocPowerPCICard(index, base);
 392    if(base->cybpci_base != NULL)
 393       context = AllocCybPCICard(index, base);
 394 #endif
 395 #ifdef __amigaos4__
 396    if(base->expansion_base != NULL)
 397       context = AllocExpansionCard(index, base);
 398 #endif
 399 #ifdef __MORPHOS__
 400    if(base->openpci_base != NULL)
 401       context = AllocOpenPCICard(index, base);
 402 #endif
 403
 404    return context;
 405 }
 406
 407
 408
 409 /****i* prism2.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
 426    if(context != NULL)
 427    {
 428 #if !(defined(__MORPHOS__) || defined(__amigaos4__))
 429       if(base->prometheus_base != NULL)
 430          FreePrometheusCard(context, base);
 431 #endif
 432 #if defined(__mc68000) && !defined(__AROS__)
 433       if(base->powerpci_base != NULL)
 434          FreePowerPCICard(context, base);
 435       if(base->cybpci_base != NULL)
 436          FreeCybPCICard(context, base);
 437 #endif
 438 #ifdef __amigaos4__
 439       if(base->expansion_base != NULL)
 440          FreeExpansionCard(context, base);
 441 #endif
 442 #ifdef __MORPHOS__
 443       if(base->openpci_base != NULL)
 444          FreeOpenPCICard(context, base);
 445 #endif
 446    }
 447
 448    return;
 449 }
 450
 451
 452
 453 /****i* prism2.device/AddPCIIntServer **************************************
 454 *
 455 *   NAME
 456 *       AddPCIIntServer
 457 *
 458 *   SYNOPSIS
 459 *       success = AddPCIIntServer(card, interrupt)
 460 *
 461 *       BOOL AddPCIIntServer(APTR, struct Interrupt *);
 462 *
 463 ****************************************************************************
 464 *
 465 */
 466
 467 static BOOL AddPCIIntServer(APTR card, struct Interrupt *interrupt,
 468    struct DevBase *base)
 469 {
 470    BOOL success;
 471
 472 #if !(defined(__MORPHOS__) || defined(__amigaos4__))
 473    if(base->prometheus_base != NULL)
 474       success = AddPrometheusIntServer(card, interrupt, base);
 475 #endif
 476 #if defined(__mc68000) && !defined(__AROS__)
 477    if(base->powerpci_base != NULL)
 478       success = AddPowerPCIIntServer(card, interrupt, base);
 479    if(base->cybpci_base != NULL)
 480       success = AddCybPCIIntServer(card, interrupt, base);
 481 #endif
 482 #ifdef __amigaos4__
 483    if(base->expansion_base != NULL)
 484       success = AddExpansionIntServer(card, interrupt, base);
 485 #endif
 486 #ifdef __MORPHOS__
 487    if(base->openpci_base != NULL)
 488       success = AddOpenPCIIntServer(card, interrupt, base);
 489 #endif
 490
 491    return success;
 492 }
 493
 494
 495
 496 /****i* prism2.device/RemPCIIntServer **************************************
 497 *
 498 *   NAME
 499 *       RemPCIIntServer
 500 *
 501 *   SYNOPSIS
 502 *       RemPCIIntServer(card, interrupt)
 503 *
 504 *       VOID RemPCIIntServer(APTR, struct Interrupt *);
 505 *
 506 ****************************************************************************
 507 *
 508 */
 509
 510 static VOID RemPCIIntServer(APTR card, struct Interrupt *interrupt,
 511    struct DevBase *base)
 512 {
 513 #if !(defined(__MORPHOS__) || defined(__amigaos4__))
 514    if(base->prometheus_base != NULL)
 515       RemPrometheusIntServer(card, interrupt, base);
 516 #endif
 517 #if defined(__mc68000) && !defined(__AROS__)
 518    if(base->powerpci_base != NULL)
 519       RemPowerPCIIntServer(card, interrupt, base);
 520    if(base->cybpci_base != NULL)
 521       RemCybPCIIntServer(card, interrupt, base);
 522 #endif
 523 #ifdef __amigaos4__
 524    if(base->expansion_base != NULL)
 525       RemExpansionIntServer(card, interrupt, base);
 526 #endif
 527 #ifdef __MORPHOS__
 528    if(base->openpci_base != NULL)
 529       RemOpenPCIIntServer(card, interrupt, base);
 530 #endif
 531
 532    return;
 533 }
 534
 535
 536
 537 /****i* prism2.device/IsCardCompatible *************************************
 538 *
 539 *   NAME
 540 *       IsCardCompatible
 541 *
 542 *   SYNOPSIS
 543 *       compatible = IsCardCompatible(context)
 544 *
 545 *       BOOL IsCardCompatible(struct BusContext *);
 546 *
 547 ****************************************************************************
 548 *
 549 */
 550
 551 BOOL IsCardCompatible(UWORD vendor_id, UWORD product_id,
 552    struct DevBase *base)
 553 {
 554    BOOL compatible = FALSE;
 555    const UWORD *p;
 556
 557    for(p = product_codes; p[0] != 0xffff; p += 2)
 558    {
 559       if(p[0] == vendor_id && p[1] == product_id)
 560          compatible = TRUE;
 561    }
 562
 563    return compatible;
 564 }
 565
 566
 567
 568 /****i* prism2.device/GetBusType *******************************************
 569 *
 570 *   NAME
 571 *       GetBusType
 572 *
 573 *   SYNOPSIS
 574 *       bus_type = GetBusType(product_id)
 575 *
 576 *       UWORD GetBusType(UWORD);
 577 *
 578 ****************************************************************************
 579 *
 580 */
 581
 582 UWORD GetBusType(UWORD product_id, struct DevBase *base)
 583 {
 584    UWORD bus_type;
 585
 586    switch(product_id)
 587    {
 588    case 0x3872:
 589    case 0x3873:
 590       bus_type = PCI_BUS;
 591       break;
 592    case 0x0131:
 593       bus_type = TMD_BUS;
 594       break;
 595    default:
 596       bus_type = PLX_BUS;
 597    }
 598
 599    return bus_type;
 600 }
 601
 602
 603
 604 /****i* prism2.device/WordsInHook ******************************************
 605 *
 606 *   NAME
 607 *       WordsInHook
 608 *
 609 *   SYNOPSIS
 610 *       WordsInHook(context, offset, buffer, count)
 611 *
 612 *       VOID WordsInHook(struct BusContext *, ULONG, UWORD *, ULONG);
 613 *
 614 ****************************************************************************
 615 *
 616 */
 617
 618 static VOID WordsInHook(struct BusContext *context, ULONG offset,
 619    UWORD *buffer, ULONG count)
 620 {
 621    volatile UWORD *reg;
 622
 623    reg = (volatile UWORD *)(context->io_base + (offset << 1));
 624    while(count-- > 0)
 625       *buffer++ = *reg;
 626
 627    return;
 628 }
 629
 630
 631
 632 /****i* prism2.device/WordsOutHook *****************************************
 633 *
 634 *   NAME
 635 *       WordsOutHook
 636 *
 637 *   SYNOPSIS
 638 *       WordsOutHook(context, offset, buffer, count)
 639 *
 640 *       VOID WordsOutHook(struct BusContext *, ULONG, const UWORD *, ULONG);
 641 *
 642 ****************************************************************************
 643 *
 644 */
 645
 646 static VOID WordsOutHook(struct BusContext *context, ULONG offset,
 647    const UWORD *buffer, ULONG count)
 648 {
 649    volatile UWORD *reg;
 650
 651    reg = (volatile UWORD *)(context->io_base + (offset << 1));
 652    while(count-- > 0)
 653       *reg = *buffer++;
 654
 655    return;
 656 }
 657
 658
 659
 660 /****i* prism2.device/BEWordOutHook ****************************************
 661 *
 662 *   NAME
 663 *       BEWordOutHook
 664 *
 665 *   SYNOPSIS
 666 *       BEWordOutHook(context, offset, value)
 667 *
 668 *       VOID BEWordOutHook(struct BusContext *, ULONG, UWORD);
 669 *
 670 ****************************************************************************
 671 *
 672 */
 673
 674 static VOID BEWordOutHook(struct BusContext *context, ULONG offset,
 675    UWORD value)
 676 {
 677    *(volatile UWORD *)(context->io_base + (offset << 1)) =
 678       MakeBEWord(value);
 679
 680    return;
 681 }
 682
 683
 684
 685 /****i* prism2.device/LEWordInHook *****************************************
 686 *
 687 *   NAME
 688 *       LEWordInHook
 689 *
 690 *   SYNOPSIS
 691 *       value = LEWordInHook(context, offset)
 692 *
 693 *       UWORD LEWordInHook(struct BusContext *, ULONG);
 694 *
 695 ****************************************************************************
 696 *
 697 */
 698
 699 static UWORD LEWordInHook(struct BusContext *context, ULONG offset)
 700 {
 701    return LEWord(*(volatile UWORD *)(context->io_base + (offset << 1)));
 702 }
 703
 704
 705
 706 /****i* prism2.device/LEWordOutHook ****************************************
 707 *
 708 *   NAME
 709 *       LEWordOutHook
 710 *
 711 *   SYNOPSIS
 712 *       LEWordOutHook(context, offset, value)
 713 *
 714 *       VOID LEWordOutHook(struct BusContext *, ULONG, UWORD);
 715 *
 716 ****************************************************************************
 717 *
 718 */
 719
 720 static VOID LEWordOutHook(struct BusContext *context, ULONG offset,
 721    UWORD value)
 722 {
 723    *(volatile UWORD *)(context->io_base + (offset << 1)) =
 724       MakeLEWord(value);
 725
 726    return;
 727 }
 728
 729
 730
 731 /****i* prism2.device/WordsInIOHook ****************************************
 732 *
 733 *   NAME
 734 *       WordsInIOHook
 735 *
 736 *   SYNOPSIS
 737 *       WordsInIOHook(context, offset, buffer, count)
 738 *
 739 *       VOID WordsInIOHook(struct BusContext *, ULONG, UWORD *, ULONG);
 740 *
 741 ****************************************************************************
 742 *
 743 */
 744
 745 static VOID WordsInIOHook(struct BusContext *context, ULONG offset,
 746    UWORD *buffer, ULONG count)
 747 {
 748    WORDSIN(context->io_base + offset, buffer, count);
 749
 750    return;
 751 }
 752
 753
 754
 755 /****i* prism2.device/WordsOutIOHook ***************************************
 756 *
 757 *   NAME
 758 *       WordsOutIOHook
 759 *
 760 *   SYNOPSIS
 761 *       WordsOutIOHook(context, offset, buffer,
 762 *           count)
 763 *
 764 *       VOID WordsOutIOHook(struct BusContext *, ULONG, const UWORD *,
 765 *           ULONG);
 766 *
 767 ****************************************************************************
 768 *
 769 */
 770
 771 static VOID WordsOutIOHook(struct BusContext *context, ULONG offset,
 772    const UWORD *buffer, ULONG count)
 773 {
 774    WORDSOUT(context->io_base + offset, buffer, count);
 775
 776    return;
 777 }
 778
 779
 780
 781 /****i* prism2.device/BEWordOutIOHook **************************************
 782 *
 783 *   NAME
 784 *       BEWordOutIOHook
 785 *
 786 *   SYNOPSIS
 787 *       BEWordOutIOHook(context, offset, value)
 788 *
 789 *       VOID BEWordOutIOHook(struct BusContext *, ULONG, UWORD);
 790 *
 791 ****************************************************************************
 792 *
 793 */
 794
 795 static VOID BEWordOutIOHook(struct BusContext *context, ULONG offset,
 796    UWORD value)
 797 {
 798    BEWORDOUT(context->io_base + offset, value);
 799
 800    return;
 801 }
 802
 803
 804
 805 /****i* prism2.device/LEWordInIOHook ***************************************
 806 *
 807 *   NAME
 808 *       LEWordInIOHook
 809 *
 810 *   SYNOPSIS
 811 *       value = LEWordInIOHook(context, offset)
 812 *
 813 *       UWORD LEWordInIOHook(struct BusContext *, ULONG);
 814 *
 815 ****************************************************************************
 816 *
 817 */
 818
 819 static UWORD LEWordInIOHook(struct BusContext *context, ULONG offset)
 820 {
 821    return LEWORDIN(context->io_base + offset);
 822 }
 823
 824
 825
 826 /****i* prism2.device/LEWordOutIOHook **************************************
 827 *
 828 *   NAME
 829 *       LEWordOutIOHook
 830 *
 831 *   SYNOPSIS
 832 *       LEWordOutIOHook(context, offset, value)
 833 *
 834 *       VOID LEWordOutIOHook(struct BusContext *, ULONG, UWORD);
 835 *
 836 ****************************************************************************
 837 *
 838 */
 839
 840 static VOID LEWordOutIOHook(struct BusContext *context, ULONG offset,
 841    UWORD value)
 842 {
 843    LEWORDOUT(context->io_base + offset, value);
 844
 845    return;
 846 }
 847
 848
 849