workbench/libs/prometheus/board.c

   1 /*
   2     Copyright © 2005-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6
   7 #include <exec/types.h>
   8 #include <utility/tagitem.h>
   9 #include <libraries/prometheus.h>
  10
  11 #include <proto/exec.h>
  12 #include <proto/kernel.h>
  13 #include <proto/utility.h>
  14 #include <proto/oop.h>
  15
  16 #include "prometheus_intern.h"
  17
  18 #define KernelBase (base->kernelBase)
  19
  20 /* Private prototypes */
  21
  22 static const struct TagItem map_tag_list[] =
  23 {
  24    {PRM_Vendor,         aoHidd_PCIDevice_VendorID},
  25    {PRM_Device,         aoHidd_PCIDevice_ProductID},
  26    {PRM_Revision,       aoHidd_PCIDevice_RevisionID},
  27    {PRM_Class,          aoHidd_PCIDevice_Class},
  28    {PRM_SubClass,       aoHidd_PCIDevice_SubClass},
  29    {PRM_MemoryAddr0,    aoHidd_PCIDevice_Base0},
  30    {PRM_MemoryAddr1,    aoHidd_PCIDevice_Base1},
  31    {PRM_MemoryAddr2,    aoHidd_PCIDevice_Base2},
  32    {PRM_MemoryAddr3,    aoHidd_PCIDevice_Base3},
  33    {PRM_MemoryAddr4,    aoHidd_PCIDevice_Base4},
  34    {PRM_MemoryAddr5,    aoHidd_PCIDevice_Base5},
  35    {PRM_ROM_Address,    aoHidd_PCIDevice_RomBase},
  36    {PRM_MemorySize0,    aoHidd_PCIDevice_Size0},
  37    {PRM_MemorySize1,    aoHidd_PCIDevice_Size1},
  38    {PRM_MemorySize2,    aoHidd_PCIDevice_Size2},
  39    {PRM_MemorySize3,    aoHidd_PCIDevice_Size3},
  40    {PRM_MemorySize4,    aoHidd_PCIDevice_Size4},
  41    {PRM_MemorySize5,    aoHidd_PCIDevice_Size5},
  42    {PRM_ROM_Size,       aoHidd_PCIDevice_RomSize},
  43    {PRM_SlotNumber,     aoHidd_PCIDevice_Dev},
  44    {PRM_FunctionNumber, aoHidd_PCIDevice_Sub},
  45    {TAG_END, 0}
  46 };
  47
  48 static const struct Node foreign_owner =
  49 {
  50     .ln_Name = "AROS"
  51 };
  52
  53 static UPINT GetOwner(struct LibBase *base, PCIBoard *board)
  54 {
  55     const struct Node *owner = board->owner;
  56
  57     if (!owner)
  58     {
  59         /*
  60          * The board is not owned via prometheus.library API.
  61          * But it could be owned via some other API. In this case
  62          * we supply own struct Node.
  63          */
  64         IPTR aros_owner;
  65
  66         OOP_GetAttr(board->aros_board, aHidd_PCIDevice_Owner, &aros_owner);
  67         if (aros_owner)
  68             owner = &foreign_owner;
  69     }
  70
  71     return (UPINT)owner;
  72 }
  73
  74 /***************************************************************************
  75
  76     NAME */
  77         AROS_LH2(PCIBoard *, Prm_FindBoardTagList,
  78
  79 /*  SYNOPSIS */
  80         AROS_LHA(PCIBoard *, previous, A0),
  81         AROS_LHA(struct TagItem *, tag_list, A1),
  82
  83 /*  LOCATION */
  84         struct Library *, PrometheusBase, 5, Prometheus)
  85
  86 /*  FUNCTION
  87         Find the board whose properties match the given set
  88         of attributes.
  89
  90     INPUTS
  91         previous - an opaque pointer to previously found board,
  92                    or NULL to start the search from the beginning
  93         tag_list - a pointer to a taglist specifying attributes to
  94                    match against. If NULL, then all boards will be
  95                    considered matching.
  96
  97     RESULT
  98         A pointer to next matching board object or NULL if the search
  99         has ended and there is no more match.
 100
 101     NOTES
 102         You can search for boards with some specific owner using
 103         PRM_BoardOwner tag. However note that in AROS prometheus.library
 104         is a wrapper on top of native object-oriented framework. This
 105         framework uses different concept of device ownership, and
 106         prometheus.library cannot determine correct owner value for devices
 107         locked using those APIs. Those devices are treated as having the
 108         same owner named "AROS", however in reality their owners will be
 109         different.
 110
 111 ***************************************************************************/
 112 {
 113    AROS_LIBFUNC_INIT
 114
 115    struct LibBase *base = (APTR)PrometheusBase;
 116    Tag tag, aros_tag;
 117    struct TagItem *temp_tag_list;
 118    struct TagItem *tag_item;
 119    struct PCIBoard *board, *tail;
 120    BOOL success = FALSE;
 121    UPINT board_data;
 122
 123    if(previous != NULL)
 124       board = (APTR)previous->node.mln_Succ;
 125    else
 126       board = (APTR)base->boards.mlh_Head;
 127    tail = (APTR)&base->boards.mlh_Tail;
 128
 129    while(board != tail && !success)
 130    {
 131       /* Check if the current board matches all requirements */
 132
 133       temp_tag_list = tag_list;
 134       success = TRUE;
 135       while((tag_item = NextTagItem(&temp_tag_list)) != NULL)
 136       {
 137          tag = tag_item->ti_Tag;
 138
 139          switch (tag)
 140          {
 141          case PRM_BoardOwner:
 142             board_data = GetOwner(base, board);
 143             break;
 144
 145          default:
 146             aros_tag = GetTagData(tag, TAG_DONE, (struct TagItem *)map_tag_list);
 147             if (aros_tag != TAG_DONE)
 148                OOP_GetAttr(board->aros_board, base->pcidevice_attr_base + aros_tag,
 149                            &board_data);
 150             else
 151                success = FALSE;
 152             break;
 153          }
 154
 155          if(board_data != tag_item->ti_Data)
 156             success = FALSE;
 157       }
 158
 159       if(!success)
 160          board = (APTR)board->node.mln_Succ;
 161    }
 162
 163    if(!success)
 164       board = NULL;
 165
 166    return board;
 167
 168    AROS_LIBFUNC_EXIT
 169 }
 170
 171 /***************************************************************************
 172
 173     NAME */
 174         AROS_LH2(ULONG, Prm_GetBoardAttrsTagList,
 175
 176 /*  SYNOPSIS */
 177         AROS_LHA(PCIBoard *, board, A0),
 178         AROS_LHA(struct TagItem *, tag_list, A1),
 179
 180 /*  LOCATION */
 181         struct Library *, PrometheusBase, 6, Prometheus)
 182
 183 /*  FUNCTION
 184         Returns information about the board according to the
 185         specified taglist.
 186
 187     INPUTS
 188         board    - an opaque pointer to board object to query
 189         tag_list - a list of attributes to query. ti_Data for
 190                    every tag should be a pointer to IPTR storage
 191                    where the data will be written. For unrecognized
 192                    tags a value of 0 will be returned. Tags with
 193                    ti_Data set to NULL will be skipped.
 194
 195     RESULT
 196         Number of succesfully processed tags.
 197
 198     NOTES
 199         AROS implementation of prometheus.library is a wrapper on top of
 200         object-oriented driver stack. Software can use either
 201         prometheus.library, or some other wrapper API (like openpci.library)
 202         or HIDD object-oriented API directly. Concept of device ownership
 203         is different across different APIs, so this method returns correct
 204         device owner only if the device was locked using prometheus.library's
 205         Prm_SetBoardAttrsTagList() function. If device's owner uses another
 206         API, prometheus.library will specify "AROS" default name.
 207
 208 ***************************************************************************/
 209 {
 210    AROS_LIBFUNC_INIT
 211
 212    struct LibBase *base = (APTR)PrometheusBase;
 213    ULONG count = 0;
 214    Tag aros_tag;
 215    UPINT *tag_data_ptr;
 216    struct TagItem *tag_item;
 217
 218    while((tag_item = NextTagItem(&tag_list)) != NULL)
 219    {
 220       if (!tag_item->ti_Data)
 221          continue;
 222
 223       if(tag_item->ti_Tag == PRM_BoardOwner)
 224       {
 225          tag_data_ptr = (UPINT *)tag_item->ti_Data;
 226          *tag_data_ptr = GetOwner(base, board);
 227          count++;
 228       }
 229       else
 230       {
 231          aros_tag = GetTagData(tag_item->ti_Tag, TAG_DONE, (struct TagItem *)map_tag_list);
 232          if(aros_tag != TAG_DONE)
 233          {
 234             OOP_GetAttr(board->aros_board,
 235                base->pcidevice_attr_base + aros_tag,
 236                (IPTR *)tag_item->ti_Data);
 237             count++;
 238          }
 239       }
 240    }
 241
 242    return count;
 243
 244    AROS_LIBFUNC_EXIT
 245 }
 246
 247
 248
 249 /***************************************************************************
 250
 251     NAME */
 252         AROS_LH2(ULONG, Prm_SetBoardAttrsTagList,
 253
 254 /*  SYNOPSIS */
 255         AROS_LHA(PCIBoard *, board, A0),
 256         AROS_LHA(struct TagItem *, tag_list, A1),
 257
 258 /*  LOCATION */
 259         struct Library *, PrometheusBase, 13, Prometheus)
 260
 261 /*  FUNCTION
 262
 263     INPUTS
 264
 265     RESULT
 266
 267 ***************************************************************************/
 268 {
 269    AROS_LIBFUNC_INIT
 270
 271    struct LibBase *base = (struct LibBase *)PrometheusBase;
 272    ULONG count = 0;
 273    struct Node *new_owner;
 274    struct TagItem *tag_item;
 275
 276    tag_item = FindTagItem(PRM_BoardOwner, tag_list);
 277    if(tag_item != NULL)
 278    {
 279       new_owner = (APTR)tag_item->ti_Data;
 280
 281       if (new_owner)
 282       {
 283          CONST_STRPTR new_str = new_owner->ln_Name;
 284          CONST_STRPTR old_str;
 285
 286          /* Just in case. We cannot specify NULL owner to PCIDevice::Obtain() */
 287          if (!new_str)
 288             new_str = base->lib_header.lib_Node.ln_Name;
 289
 290          old_str = HIDD_PCIDevice_Obtain(board->aros_board, new_str);
 291          if (!old_str)
 292          {
 293             board->owner = new_owner;
 294             count++;
 295          }
 296       }
 297       else if (board->owner)
 298       {
 299          HIDD_PCIDevice_Release(board->aros_board);
 300          board->owner = NULL;
 301          count++;
 302       }
 303    }
 304
 305    return count;
 306
 307    AROS_LIBFUNC_EXIT
 308 }
 309
 310
 311
 312 /***************************************************************************
 313
 314     NAME */
 315         AROS_LH2(UBYTE, Prm_ReadConfigByte,
 316
 317 /*  SYNOPSIS */
 318         AROS_LHA(PCIBoard *, board, A0),
 319         AROS_LHA(UBYTE, offset, D0),
 320
 321 /*  LOCATION */
 322         struct Library *, PrometheusBase, 9, Prometheus)
 323
 324 /*  FUNCTION
 325
 326     INPUTS
 327
 328     RESULT
 329
 330 ***************************************************************************/
 331 {
 332    AROS_LIBFUNC_INIT
 333
 334    struct LibBase *base = (struct LibBase *)PrometheusBase;
 335
 336    return HIDD_PCIDevice_ReadConfigByte(board->aros_board, offset);
 337
 338    AROS_LIBFUNC_EXIT
 339 }
 340
 341
 342
 343 /***************************************************************************
 344
 345     NAME */
 346         AROS_LH3(VOID, Prm_WriteConfigByte,
 347
 348 /*  SYNOPSIS */
 349         AROS_LHA(PCIBoard *, board, A0),
 350         AROS_LHA(UBYTE, data, D0),
 351         AROS_LHA(UBYTE, offset, D1),
 352
 353 /*  LOCATION */
 354         struct Library *, PrometheusBase, 12, Prometheus)
 355
 356 /*  FUNCTION
 357
 358     INPUTS
 359
 360     RESULT
 361
 362 ***************************************************************************/
 363 {
 364    AROS_LIBFUNC_INIT
 365
 366    struct LibBase *base = (struct LibBase *)PrometheusBase;
 367
 368    HIDD_PCIDevice_WriteConfigByte(board->aros_board, offset, data);
 369
 370    AROS_LIBFUNC_EXIT
 371 }
 372
 373
 374
 375 /***************************************************************************
 376
 377     NAME */
 378         AROS_LH2(UWORD, Prm_ReadConfigWord,
 379
 380 /*  SYNOPSIS */
 381         AROS_LHA(PCIBoard *, board, A0),
 382         AROS_LHA(UBYTE, offset, D0),
 383
 384 /*  LOCATION */
 385         struct Library *, PrometheusBase, 8, Prometheus)
 386
 387 /*  FUNCTION
 388
 389     INPUTS
 390
 391     RESULT
 392
 393 ***************************************************************************/
 394 {
 395    AROS_LIBFUNC_INIT
 396
 397    struct LibBase *base = (struct LibBase *)PrometheusBase;
 398
 399    return HIDD_PCIDevice_ReadConfigWord(board->aros_board, offset & ~0x1);
 400
 401    AROS_LIBFUNC_EXIT
 402 }
 403
 404
 405
 406 /***************************************************************************
 407
 408     NAME */
 409         AROS_LH3(VOID, Prm_WriteConfigWord,
 410
 411 /*  SYNOPSIS */
 412         AROS_LHA(PCIBoard *, board, A0),
 413         AROS_LHA(UWORD, data, D0),
 414         AROS_LHA(UBYTE, offset, D1),
 415
 416 /*  LOCATION */
 417         struct Library *, PrometheusBase, 11, Prometheus)
 418
 419 /*  FUNCTION
 420
 421     INPUTS
 422
 423     RESULT
 424
 425 ***************************************************************************/
 426 {
 427    AROS_LIBFUNC_INIT
 428
 429    struct LibBase *base = (struct LibBase *)PrometheusBase;
 430
 431    HIDD_PCIDevice_WriteConfigWord(board->aros_board, offset & ~0x1, data);
 432
 433    AROS_LIBFUNC_EXIT
 434 }
 435
 436
 437
 438 /***************************************************************************
 439
 440     NAME */
 441         AROS_LH2(ULONG, Prm_ReadConfigLong,
 442
 443 /*  SYNOPSIS */
 444         AROS_LHA(PCIBoard *, board, A0),
 445         AROS_LHA(UBYTE, offset, D0),
 446
 447 /*  LOCATION */
 448         struct Library *, PrometheusBase, 7, Prometheus)
 449
 450 /*  FUNCTION
 451
 452     INPUTS
 453
 454     RESULT
 455
 456 ***************************************************************************/
 457 {
 458    AROS_LIBFUNC_INIT
 459
 460    struct LibBase *base = (struct LibBase *)PrometheusBase;
 461
 462    return HIDD_PCIDevice_ReadConfigLong(board->aros_board, offset & ~0x3);
 463
 464    AROS_LIBFUNC_EXIT
 465 }
 466
 467
 468
 469 /***************************************************************************
 470
 471     NAME */
 472         AROS_LH3(VOID, Prm_WriteConfigLong,
 473
 474 /*  SYNOPSIS */
 475         AROS_LHA(PCIBoard *, board, A0),
 476         AROS_LHA(ULONG, data, D0),
 477         AROS_LHA(UBYTE, offset, D1),
 478
 479 /*  LOCATION */
 480         struct Library *, PrometheusBase, 10, Prometheus)
 481
 482 /*  FUNCTION
 483
 484     INPUTS
 485
 486     RESULT
 487
 488 ***************************************************************************/
 489 {
 490    AROS_LIBFUNC_INIT
 491
 492    struct LibBase *base = (struct LibBase *)PrometheusBase;
 493
 494    HIDD_PCIDevice_WriteConfigLong(board->aros_board, offset & ~0x3, data);
 495
 496    AROS_LIBFUNC_EXIT
 497 }
 498
 499
 500
 501 /***************************************************************************
 502
 503     NAME */
 504         AROS_LH2(BOOL, Prm_AddIntServer,
 505
 506 /*  SYNOPSIS */
 507         AROS_LHA(PCIBoard *, board, A0),
 508         AROS_LHA(struct Interrupt *, interrupt, A1),
 509
 510 /*  LOCATION */
 511         struct Library *, PrometheusBase, 14, Prometheus)
 512
 513 /*  FUNCTION
 514
 515     INPUTS
 516
 517     RESULT
 518
 519 ***************************************************************************/
 520 {
 521    AROS_LIBFUNC_INIT
 522
 523    struct LibBase *base = (APTR)PrometheusBase;
 524    BOOL success = FALSE;
 525
 526    /* Add AROS int to system */
 527    if (board)
 528       success = HIDD_PCIDevice_AddInterrupt(board->aros_board, interrupt);
 529
 530    return success;
 531
 532    AROS_LIBFUNC_EXIT
 533 }
 534
 535
 536
 537 /***************************************************************************
 538
 539     NAME */
 540         AROS_LH2(VOID, Prm_RemIntServer,
 541
 542 /*  SYNOPSIS */
 543         AROS_LHA(PCIBoard *, board, A0),
 544         AROS_LHA(struct Interrupt *, interrupt, A1),
 545
 546 /*  LOCATION */
 547         struct Library *, PrometheusBase, 15, Prometheus)
 548
 549 /*  FUNCTION
 550
 551     INPUTS
 552
 553     RESULT
 554
 555 ***************************************************************************/
 556 {
 557    AROS_LIBFUNC_INIT
 558
 559    struct LibBase *base = (APTR)PrometheusBase;
 560
 561    if(board != NULL)
 562       HIDD_PCIDevice_RemoveInterrupt(board->aros_board, interrupt);
 563
 564    AROS_LIBFUNC_EXIT
 565 }
 566
 567
 568
 569 /***************************************************************************
 570
 571     NAME */
 572         AROS_LH1(APTR, Prm_AllocDMABuffer,
 573
 574 /*  SYNOPSIS */
 575         AROS_LHA(ULONG, size, D0),
 576
 577 /*  LOCATION */
 578         struct Library *, PrometheusBase, 16, Prometheus)
 579
 580 /*  FUNCTION
 581         Allocate memory region accessible by PCI DMA.
 582
 583     INPUTS
 584         size - Size of the region to allocate. NULL is safe
 585                input, in this case the function fails.
 586
 587     RESULT
 588         A pointer to allocated region or NULL upon failure.
 589         The region will always be LONG-aligned.
 590
 591 ***************************************************************************/
 592 {
 593    AROS_LIBFUNC_INIT
 594
 595    /*
 596     * This should be OK for any "direct" PCI bus.
 597     * Note that this also relies on AllocMem()'s ability to return
 598     * NULL when zero size is given.
 599     */
 600    return AllocMem(size, MEMF_31BIT);
 601
 602    AROS_LIBFUNC_EXIT
 603 }
 604
 605
 606
 607 /***************************************************************************
 608
 609     NAME */
 610         AROS_LH2(VOID, Prm_FreeDMABuffer,
 611
 612 /*  SYNOPSIS */
 613         AROS_LHA(APTR, buffer, A0),
 614         AROS_LHA(ULONG, size, D0),
 615
 616 /*  LOCATION */
 617         struct Library *, PrometheusBase, 17, Prometheus)
 618
 619 /*  FUNCTION
 620         Free memory buffer allocated by Prm_AllocDMABuffer().
 621
 622     INPUTS
 623         buffer - a pointer to a buffer to free. NULL is a safe value,
 624                  in this case the function does nothing.
 625         size   - size of the buffer. Zero is a safe value, in this case
 626                  the function does nothing.
 627
 628     RESULT
 629         None.
 630
 631 ***************************************************************************/
 632 {
 633    AROS_LIBFUNC_INIT
 634
 635    /*
 636     * Note that this relies on FreeMem()'s ability to ignore
 637     * zero buffer or size.
 638     */
 639    FreeMem(buffer, size);
 640
 641    AROS_LIBFUNC_EXIT
 642 }
 643
 644
 645
 646 /***************************************************************************
 647
 648     NAME */
 649         AROS_LH1(APTR, Prm_GetPhysicalAddr,
 650
 651 /*  SYNOPSIS */
 652         AROS_LHA(APTR, address, D0),
 653
 654 /*  LOCATION */
 655         struct Library *, PrometheusBase, 18, Prometheus)
 656
 657 /*  FUNCTION
 658
 659     INPUTS
 660
 661     RESULT
 662
 663 ***************************************************************************/
 664 {
 665    AROS_LIBFUNC_INIT
 666
 667    struct LibBase *base = (struct LibBase *)PrometheusBase;
 668
 669    /* This should be OK for any "direct" PCI bus */
 670    return KrnVirtualToPhysical(address);
 671
 672    AROS_LIBFUNC_EXIT
 673 }