workbench/libs/prometheus/board.c

   1 /*
   2     Copyright (C) 2005 Neil Cafferkey
   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/utility.h>
  13 #include <proto/oop.h>
  14
  15 #include "prometheus_intern.h"
  16
  17
  18 /* Private prototypes */
  19
  20 static VOID WrapperIRQ(HIDDT_IRQ_Handler *irq, HIDDT_IRQ_HwInfo *hw_info);
  21
  22
  23 static const struct TagItem map_tag_list[] =
  24 {
  25    {PRM_Vendor,         aoHidd_PCIDevice_VendorID},
  26    {PRM_Device,         aoHidd_PCIDevice_ProductID},
  27    {PRM_Revision,       aoHidd_PCIDevice_RevisionID},
  28    {PRM_Class,          aoHidd_PCIDevice_Class},
  29    {PRM_SubClass,       aoHidd_PCIDevice_SubClass},
  30    {PRM_MemoryAddr0,    aoHidd_PCIDevice_Base0},
  31    {PRM_MemoryAddr1,    aoHidd_PCIDevice_Base1},
  32    {PRM_MemoryAddr2,    aoHidd_PCIDevice_Base2},
  33    {PRM_MemoryAddr3,    aoHidd_PCIDevice_Base3},
  34    {PRM_MemoryAddr4,    aoHidd_PCIDevice_Base4},
  35    {PRM_MemoryAddr5,    aoHidd_PCIDevice_Base5},
  36    {PRM_ROM_Address,    aoHidd_PCIDevice_RomBase},
  37    {PRM_MemorySize0,    aoHidd_PCIDevice_Size0},
  38    {PRM_MemorySize1,    aoHidd_PCIDevice_Size1},
  39    {PRM_MemorySize2,    aoHidd_PCIDevice_Size2},
  40    {PRM_MemorySize3,    aoHidd_PCIDevice_Size3},
  41    {PRM_MemorySize4,    aoHidd_PCIDevice_Size4},
  42    {PRM_MemorySize5,    aoHidd_PCIDevice_Size5},
  43    {PRM_ROM_Size,       aoHidd_PCIDevice_RomSize},
  44    {PRM_SlotNumber,     aoHidd_PCIDevice_Dev},
  45    {PRM_FunctionNumber, aoHidd_PCIDevice_Sub},
  46    {TAG_END, 0}
  47 };
  48
  49
  50 /***************************************************************************
  51
  52     NAME */
  53         AROS_LH2(PCIBoard *, Prm_FindBoardTagList,
  54
  55 /*  SYNOPSIS */
  56         AROS_LHA(PCIBoard *, previous, A0),
  57         AROS_LHA(struct TagItem *, tag_list, A1),
  58
  59 /*  LOCATION */
  60         struct Library *, PrometheusBase, 5, Prometheus)
  61
  62 /*  FUNCTION
  63
  64     INPUTS
  65
  66     RESULT
  67
  68 ***************************************************************************/
  69 {
  70    AROS_LIBFUNC_INIT
  71
  72    struct LibBase *base = (APTR)PrometheusBase;
  73    Tag tag, aros_tag;
  74    const struct TagItem *temp_tag_list;
  75    struct TagItem *tag_item;
  76    struct PCIBoard *board, *tail;
  77    BOOL success = FALSE;
  78    UPINT board_data;
  79
  80    if(previous != NULL)
  81       board = (APTR)previous->node.mln_Succ;
  82    else
  83       board = (APTR)base->boards.mlh_Head;
  84    tail = (APTR)&base->boards.mlh_Tail;
  85
  86    while(board != tail && !success)
  87    {
  88       /* Check if the current board matches all requirements */
  89
  90       temp_tag_list = tag_list;
  91       success = TRUE;
  92       while((tag_item = NextTagItem(&temp_tag_list)) != NULL)
  93       {
  94          tag = tag_item->ti_Tag;
  95          aros_tag = GetTagData(tag, TAG_DONE, (const struct TagItem *)map_tag_list);
  96          if(aros_tag != TAG_DONE)
  97          {
  98             OOP_GetAttr(board->aros_board,
  99                base->pcidevice_attr_base + aros_tag, (IPTR *)&board_data);
 100          }
 101          else if(tag == PRM_BoardOwner)
 102             board_data = (UPINT)board->owner;
 103
 104          if(board_data != tag_item->ti_Data)
 105             success = FALSE;
 106       }
 107
 108       if(!success)
 109          board = (APTR)board->node.mln_Succ;
 110    }
 111
 112    if(!success)
 113       board = NULL;
 114
 115    return board;
 116
 117    AROS_LIBFUNC_EXIT
 118 }
 119
 120
 121
 122 /***************************************************************************
 123
 124     NAME */
 125         AROS_LH2(ULONG, Prm_GetBoardAttrsTagList,
 126
 127 /*  SYNOPSIS */
 128         AROS_LHA(PCIBoard *, board, A0),
 129         AROS_LHA(struct TagItem *, tag_list, A1),
 130
 131 /*  LOCATION */
 132         struct Library *, PrometheusBase, 6, Prometheus)
 133
 134 /*  FUNCTION
 135
 136     INPUTS
 137
 138     RESULT
 139
 140 ***************************************************************************/
 141 {
 142    AROS_LIBFUNC_INIT
 143
 144    struct LibBase *base = (APTR)PrometheusBase;
 145    ULONG count = 0;
 146    Tag aros_tag;
 147    UPINT *tag_data_ptr;
 148    struct TagItem *tag_item;
 149
 150    while((tag_item = NextTagItem((const struct TagItem **)&tag_list)) != NULL)
 151    {
 152       if(tag_item->ti_Tag == PRM_BoardOwner)
 153       {
 154          tag_data_ptr = (UPINT *)tag_item->ti_Data;
 155          *tag_data_ptr = (UPINT)board->owner;
 156          count++;
 157       }
 158       else
 159       {
 160          aros_tag = GetTagData(tag_item->ti_Tag, TAG_DONE, map_tag_list);
 161          if(aros_tag != TAG_DONE)
 162          {
 163             OOP_GetAttr(board->aros_board,
 164                base->pcidevice_attr_base + aros_tag,
 165                (IPTR *)tag_item->ti_Data);
 166             count++;
 167          }
 168       }
 169    }
 170
 171    return count;
 172
 173    AROS_LIBFUNC_EXIT
 174 }
 175
 176
 177
 178 /***************************************************************************
 179
 180     NAME */
 181         AROS_LH2(ULONG, Prm_SetBoardAttrsTagList,
 182
 183 /*  SYNOPSIS */
 184         AROS_LHA(PCIBoard *, board, A0),
 185         AROS_LHA(struct TagItem *, tag_list, A1),
 186
 187 /*  LOCATION */
 188         struct Library *, PrometheusBase, 13, Prometheus)
 189
 190 /*  FUNCTION
 191
 192     INPUTS
 193
 194     RESULT
 195
 196 ***************************************************************************/
 197 {
 198    AROS_LIBFUNC_INIT
 199
 200    ULONG count = 0;
 201    APTR new_owner;
 202    struct TagItem *tag_item;
 203
 204    tag_item = FindTagItem(PRM_BoardOwner, tag_list);
 205    if(tag_item != NULL)
 206    {
 207       new_owner = (APTR)tag_item->ti_Data;
 208       if(new_owner != NULL && board->owner == NULL
 209          || new_owner == NULL && board->owner != NULL)
 210       {
 211          board->owner = new_owner;
 212          count++;
 213       }
 214    }
 215
 216    return count;
 217
 218    AROS_LIBFUNC_EXIT
 219 }
 220
 221
 222
 223 /***************************************************************************
 224
 225     NAME */
 226         AROS_LH2(UBYTE, Prm_ReadConfigByte,
 227
 228 /*  SYNOPSIS */
 229         AROS_LHA(PCIBoard *, board, A0),
 230         AROS_LHA(UBYTE, offset, D0),
 231
 232 /*  LOCATION */
 233         struct Library *, PrometheusBase, 9, Prometheus)
 234
 235 /*  FUNCTION
 236
 237     INPUTS
 238
 239     RESULT
 240
 241 ***************************************************************************/
 242 {
 243    AROS_LIBFUNC_INIT
 244
 245    struct pHidd_PCIDevice_ReadConfigByte message;
 246
 247    message.mID =
 248       OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigByte);
 249    message.reg = offset;
 250
 251    return (UBYTE)OOP_DoMethod(board->aros_board, (OOP_Msg)&message);
 252
 253    AROS_LIBFUNC_EXIT
 254 }
 255
 256
 257
 258 /***************************************************************************
 259
 260     NAME */
 261         AROS_LH3(VOID, Prm_WriteConfigByte,
 262
 263 /*  SYNOPSIS */
 264         AROS_LHA(PCIBoard *, board, A0),
 265         AROS_LHA(UBYTE, data, D0),
 266         AROS_LHA(UBYTE, offset, D1),
 267
 268 /*  LOCATION */
 269         struct Library *, PrometheusBase, 12, Prometheus)
 270
 271 /*  FUNCTION
 272
 273     INPUTS
 274
 275     RESULT
 276
 277 ***************************************************************************/
 278 {
 279    AROS_LIBFUNC_INIT
 280
 281    struct pHidd_PCIDevice_WriteConfigByte message;
 282
 283    message.mID =
 284       OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigByte);
 285    message.reg = offset;
 286    message.val = data;
 287
 288    OOP_DoMethod(board->aros_board, (OOP_Msg)&message);
 289
 290    AROS_LIBFUNC_EXIT
 291 }
 292
 293
 294
 295 /***************************************************************************
 296
 297     NAME */
 298         AROS_LH2(UWORD, Prm_ReadConfigWord,
 299
 300 /*  SYNOPSIS */
 301         AROS_LHA(PCIBoard *, board, A0),
 302         AROS_LHA(UBYTE, offset, D0),
 303
 304 /*  LOCATION */
 305         struct Library *, PrometheusBase, 8, Prometheus)
 306
 307 /*  FUNCTION
 308
 309     INPUTS
 310
 311     RESULT
 312
 313 ***************************************************************************/
 314 {
 315    AROS_LIBFUNC_INIT
 316
 317    struct pHidd_PCIDevice_ReadConfigWord message;
 318
 319    message.mID =
 320       OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigWord);
 321    message.reg = offset & ~0x1;
 322
 323    return (UWORD)OOP_DoMethod(board->aros_board, (OOP_Msg)&message);
 324
 325    AROS_LIBFUNC_EXIT
 326 }
 327
 328
 329
 330 /***************************************************************************
 331
 332     NAME */
 333         AROS_LH3(VOID, Prm_WriteConfigWord,
 334
 335 /*  SYNOPSIS */
 336         AROS_LHA(PCIBoard *, board, A0),
 337         AROS_LHA(UWORD, data, D0),
 338         AROS_LHA(UBYTE, offset, D1),
 339
 340 /*  LOCATION */
 341         struct Library *, PrometheusBase, 11, Prometheus)
 342
 343 /*  FUNCTION
 344
 345     INPUTS
 346
 347     RESULT
 348
 349 ***************************************************************************/
 350 {
 351    AROS_LIBFUNC_INIT
 352
 353    struct pHidd_PCIDevice_WriteConfigWord message;
 354
 355    message.mID =
 356       OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigWord);
 357    message.reg = offset & ~0x1;
 358    message.val = data;
 359
 360    OOP_DoMethod(board->aros_board, (OOP_Msg)&message);
 361
 362    AROS_LIBFUNC_EXIT
 363 }
 364
 365
 366
 367 /***************************************************************************
 368
 369     NAME */
 370         AROS_LH2(ULONG, Prm_ReadConfigLong,
 371
 372 /*  SYNOPSIS */
 373         AROS_LHA(PCIBoard *, board, A0),
 374         AROS_LHA(UBYTE, offset, D0),
 375
 376 /*  LOCATION */
 377         struct Library *, PrometheusBase, 7, Prometheus)
 378
 379 /*  FUNCTION
 380
 381     INPUTS
 382
 383     RESULT
 384
 385 ***************************************************************************/
 386 {
 387    AROS_LIBFUNC_INIT
 388
 389    struct pHidd_PCIDevice_ReadConfigLong message;
 390
 391    message.mID =
 392       OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigLong);
 393    message.reg = offset & ~0x3;
 394
 395    return (ULONG)OOP_DoMethod(board->aros_board, (OOP_Msg)&message);
 396
 397    AROS_LIBFUNC_EXIT
 398 }
 399
 400
 401
 402 /***************************************************************************
 403
 404     NAME */
 405         AROS_LH3(VOID, Prm_WriteConfigLong,
 406
 407 /*  SYNOPSIS */
 408         AROS_LHA(PCIBoard *, board, A0),
 409         AROS_LHA(ULONG, data, D0),
 410         AROS_LHA(UBYTE, offset, D1),
 411
 412 /*  LOCATION */
 413         struct Library *, PrometheusBase, 10, Prometheus)
 414
 415 /*  FUNCTION
 416
 417     INPUTS
 418
 419     RESULT
 420
 421 ***************************************************************************/
 422 {
 423    AROS_LIBFUNC_INIT
 424
 425    struct pHidd_PCIDevice_WriteConfigLong message;
 426
 427    message.mID =
 428       OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigLong);
 429    message.reg = offset & ~0x3;
 430    message.val = data;
 431
 432    OOP_DoMethod(board->aros_board, (OOP_Msg)&message);
 433
 434    AROS_LIBFUNC_EXIT
 435 }
 436
 437
 438
 439 /***************************************************************************
 440
 441     NAME */
 442         AROS_LH2(BOOL, Prm_AddIntServer,
 443
 444 /*  SYNOPSIS */
 445         AROS_LHA(PCIBoard *, board, A0),
 446         AROS_LHA(struct Interrupt *, interrupt, A1),
 447
 448 /*  LOCATION */
 449         struct Library *, PrometheusBase, 14, Prometheus)
 450
 451 /*  FUNCTION
 452
 453     INPUTS
 454
 455     RESULT
 456
 457 ***************************************************************************/
 458 {
 459    AROS_LIBFUNC_INIT
 460
 461    struct LibBase *base = (APTR)PrometheusBase;
 462    BOOL success = TRUE;
 463    HIDDT_IRQ_Handler *aros_irq;
 464    UPINT int_no;
 465
 466    /* Allocate AROS int structure */
 467
 468    if(board == NULL || board->aros_irq != NULL)
 469       success = FALSE;
 470
 471    if(success)
 472    {
 473       aros_irq =
 474          AllocMem(sizeof(HIDDT_IRQ_Handler), MEMF_PUBLIC | MEMF_CLEAR);
 475       if(aros_irq == NULL)
 476          success = FALSE;
 477    }
 478
 479    /* Add AROS int to system */
 480
 481    if(success)
 482    {
 483       OOP_GetAttr(board->aros_board,
 484          base->pcidevice_attr_base + aoHidd_PCIDevice_INTLine, (IPTR *)&int_no);
 485       board->aros_irq = aros_irq;
 486       aros_irq->h_Node.ln_Name = interrupt->is_Node.ln_Name;
 487       aros_irq->h_Code = WrapperIRQ;
 488       aros_irq->h_Data = interrupt;
 489
 490       success = HIDD_IRQ_AddHandler(base->irq_hidd, aros_irq, int_no);
 491    }
 492
 493    return success;
 494
 495    AROS_LIBFUNC_EXIT
 496 }
 497
 498
 499
 500 /***************************************************************************
 501
 502     NAME */
 503         AROS_LH2(VOID, Prm_RemIntServer,
 504
 505 /*  SYNOPSIS */
 506         AROS_LHA(PCIBoard *, board, A0),
 507         AROS_LHA(struct Interrupt *, interrupt, A1),
 508
 509 /*  LOCATION */
 510         struct Library *, PrometheusBase, 15, Prometheus)
 511
 512 /*  FUNCTION
 513
 514     INPUTS
 515
 516     RESULT
 517
 518 ***************************************************************************/
 519 {
 520    AROS_LIBFUNC_INIT
 521
 522    struct LibBase *base = (APTR)PrometheusBase;
 523
 524    if(board != NULL)
 525    {
 526       HIDD_IRQ_RemHandler(base->irq_hidd, board->aros_irq);
 527       FreeMem(board->aros_irq, sizeof(HIDDT_IRQ_Handler));
 528       board->aros_irq = NULL;
 529    }
 530
 531    return;
 532
 533    AROS_LIBFUNC_EXIT
 534 }
 535
 536
 537
 538 /***************************************************************************
 539
 540     NAME */
 541         AROS_LH1(APTR, Prm_AllocDMABuffer,
 542
 543 /*  SYNOPSIS */
 544         AROS_LHA(ULONG, size, D0),
 545
 546 /*  LOCATION */
 547         struct Library *, PrometheusBase, 16, Prometheus)
 548
 549 /*  FUNCTION
 550
 551     INPUTS
 552
 553     RESULT
 554
 555 ***************************************************************************/
 556 {
 557    AROS_LIBFUNC_INIT
 558
 559    APTR buffer;
 560
 561    if(size != 0)
 562       buffer = AllocMem(size, MEMF_PUBLIC);
 563    else
 564       buffer = NULL;
 565
 566    return buffer;
 567
 568    AROS_LIBFUNC_EXIT
 569 }
 570
 571
 572
 573 /***************************************************************************
 574
 575     NAME */
 576         AROS_LH2(VOID, Prm_FreeDMABuffer,
 577
 578 /*  SYNOPSIS */
 579         AROS_LHA(APTR, buffer, A0),
 580         AROS_LHA(ULONG, size, D0),
 581
 582 /*  LOCATION */
 583         struct Library *, PrometheusBase, 17, Prometheus)
 584
 585 /*  FUNCTION
 586
 587     INPUTS
 588
 589     RESULT
 590
 591 ***************************************************************************/
 592 {
 593    AROS_LIBFUNC_INIT
 594
 595    if(buffer != NULL && size != 0)
 596       FreeMem(buffer, size);
 597
 598    return;
 599
 600    AROS_LIBFUNC_EXIT
 601 }
 602
 603
 604
 605 /***************************************************************************
 606
 607     NAME */
 608         AROS_LH1(APTR, Prm_GetPhysicalAddr,
 609
 610 /*  SYNOPSIS */
 611         AROS_LHA(APTR, address, D0),
 612
 613 /*  LOCATION */
 614         struct Library *, PrometheusBase, 18, Prometheus)
 615
 616 /*  FUNCTION
 617
 618     INPUTS
 619
 620     RESULT
 621
 622 ***************************************************************************/
 623 {
 624    AROS_LIBFUNC_INIT
 625
 626    return address;
 627
 628    AROS_LIBFUNC_EXIT
 629 }
 630
 631
 632
 633 static VOID WrapperIRQ(HIDDT_IRQ_Handler *irq, HIDDT_IRQ_HwInfo *hw_info)
 634 {
 635    struct Interrupt *interrupt;
 636
 637    interrupt = (struct Interrupt *)irq->h_Data;
 638    AROS_UFC2(BOOL, interrupt->is_Code,
 639       AROS_UFCA(APTR, interrupt->is_Data, A1),
 640       AROS_UFCA(APTR, interrupt->is_Code, A5));
 641
 642    return;
 643 }
 644
 645
 646