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    ULONG count = 0;
  74    Tag tag, aros_tag;
  75    struct TagItem *tag_item, *temp_tag_list;
  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, map_tag_list);
  96          if(aros_tag != TAG_DONE)
  97          {
  98             OOP_GetAttr(board->aros_board,
  99                base->pcidevice_attr_base + aros_tag, &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(&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                (UPINT *)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    struct LibBase *base = (APTR)PrometheusBase;
 201    ULONG count = 0;
 202    APTR new_owner;
 203    struct TagItem *tag_item;
 204
 205    tag_item = FindTagItem(PRM_BoardOwner, tag_list);
 206    if(tag_item != NULL)
 207    {
 208       new_owner = (APTR)tag_item->ti_Data;
 209       if(new_owner != NULL && board->owner == NULL
 210          || new_owner == NULL && board->owner != NULL)
 211       {
 212          board->owner = new_owner;
 213          count++;
 214       }
 215    }
 216
 217    return count;
 218
 219    AROS_LIBFUNC_EXIT
 220 }
 221
 222
 223
 224 /***************************************************************************
 225
 226     NAME */
 227         AROS_LH2(UBYTE, Prm_ReadConfigByte,
 228
 229 /*  SYNOPSIS */
 230         AROS_LHA(PCIBoard *, board, A0),
 231         AROS_LHA(UBYTE, offset, D0),
 232
 233 /*  LOCATION */
 234         struct Library *, PrometheusBase, 9, Prometheus)
 235
 236 /*  FUNCTION
 237
 238     INPUTS
 239
 240     RESULT
 241
 242 ***************************************************************************/
 243 {
 244    AROS_LIBFUNC_INIT
 245
 246    struct LibBase *base = (APTR)PrometheusBase;
 247    struct pHidd_PCIDevice_ReadConfigByte message;
 248
 249    message.mID =
 250       OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigByte);
 251    message.reg = offset;
 252
 253    return (UBYTE)OOP_DoMethod(board->aros_board, (OOP_Msg)&message);
 254
 255    AROS_LIBFUNC_EXIT
 256 }
 257
 258
 259
 260 /***************************************************************************
 261
 262     NAME */
 263         AROS_LH3(VOID, Prm_WriteConfigByte,
 264
 265 /*  SYNOPSIS */
 266         AROS_LHA(PCIBoard *, board, A0),
 267         AROS_LHA(UBYTE, data, D0),
 268         AROS_LHA(UBYTE, offset, D1),
 269
 270 /*  LOCATION */
 271         struct Library *, PrometheusBase, 12, Prometheus)
 272
 273 /*  FUNCTION
 274
 275     INPUTS
 276
 277     RESULT
 278
 279 ***************************************************************************/
 280 {
 281    AROS_LIBFUNC_INIT
 282
 283    struct LibBase *base = (APTR)PrometheusBase;
 284    struct pHidd_PCIDevice_WriteConfigByte message;
 285
 286    message.mID =
 287       OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigByte);
 288    message.reg = offset;
 289    message.val = data;
 290
 291    OOP_DoMethod(board->aros_board, (OOP_Msg)&message);
 292
 293    AROS_LIBFUNC_EXIT
 294 }
 295
 296
 297
 298 /***************************************************************************
 299
 300     NAME */
 301         AROS_LH2(UWORD, Prm_ReadConfigWord,
 302
 303 /*  SYNOPSIS */
 304         AROS_LHA(PCIBoard *, board, A0),
 305         AROS_LHA(UBYTE, offset, D0),
 306
 307 /*  LOCATION */
 308         struct Library *, PrometheusBase, 8, Prometheus)
 309
 310 /*  FUNCTION
 311
 312     INPUTS
 313
 314     RESULT
 315
 316 ***************************************************************************/
 317 {
 318    AROS_LIBFUNC_INIT
 319
 320    struct LibBase *base = (APTR)PrometheusBase;
 321    struct pHidd_PCIDevice_ReadConfigWord message;
 322
 323    message.mID =
 324       OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigWord);
 325    message.reg = offset & ~0x1;
 326
 327    return (UWORD)OOP_DoMethod(board->aros_board, (OOP_Msg)&message);
 328
 329    AROS_LIBFUNC_EXIT
 330 }
 331
 332
 333
 334 /***************************************************************************
 335
 336     NAME */
 337         AROS_LH3(VOID, Prm_WriteConfigWord,
 338
 339 /*  SYNOPSIS */
 340         AROS_LHA(PCIBoard *, board, A0),
 341         AROS_LHA(UWORD, data, D0),
 342         AROS_LHA(UBYTE, offset, D1),
 343
 344 /*  LOCATION */
 345         struct Library *, PrometheusBase, 11, Prometheus)
 346
 347 /*  FUNCTION
 348
 349     INPUTS
 350
 351     RESULT
 352
 353 ***************************************************************************/
 354 {
 355    AROS_LIBFUNC_INIT
 356
 357    struct LibBase *base = (APTR)PrometheusBase;
 358    struct pHidd_PCIDevice_WriteConfigWord message;
 359
 360    message.mID =
 361       OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigWord);
 362    message.reg = offset & ~0x1;
 363    message.val = data;
 364
 365    OOP_DoMethod(board->aros_board, (OOP_Msg)&message);
 366
 367    AROS_LIBFUNC_EXIT
 368 }
 369
 370
 371
 372 /***************************************************************************
 373
 374     NAME */
 375         AROS_LH2(ULONG, Prm_ReadConfigLong,
 376
 377 /*  SYNOPSIS */
 378         AROS_LHA(PCIBoard *, board, A0),
 379         AROS_LHA(UBYTE, offset, D0),
 380
 381 /*  LOCATION */
 382         struct Library *, PrometheusBase, 7, Prometheus)
 383
 384 /*  FUNCTION
 385
 386     INPUTS
 387
 388     RESULT
 389
 390 ***************************************************************************/
 391 {
 392    AROS_LIBFUNC_INIT
 393
 394    struct LibBase *base = (APTR)PrometheusBase;
 395    struct pHidd_PCIDevice_ReadConfigLong message;
 396
 397    message.mID =
 398       OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_ReadConfigLong);
 399    message.reg = offset & ~0x3;
 400
 401    return (ULONG)OOP_DoMethod(board->aros_board, (OOP_Msg)&message);
 402
 403    AROS_LIBFUNC_EXIT
 404 }
 405
 406
 407
 408 /***************************************************************************
 409
 410     NAME */
 411         AROS_LH3(VOID, Prm_WriteConfigLong,
 412
 413 /*  SYNOPSIS */
 414         AROS_LHA(PCIBoard *, board, A0),
 415         AROS_LHA(ULONG, data, D0),
 416         AROS_LHA(UBYTE, offset, D1),
 417
 418 /*  LOCATION */
 419         struct Library *, PrometheusBase, 10, Prometheus)
 420
 421 /*  FUNCTION
 422
 423     INPUTS
 424
 425     RESULT
 426
 427 ***************************************************************************/
 428 {
 429    AROS_LIBFUNC_INIT
 430
 431    struct LibBase *base = (APTR)PrometheusBase;
 432    struct pHidd_PCIDevice_WriteConfigLong message;
 433
 434    message.mID =
 435       OOP_GetMethodID(IID_Hidd_PCIDevice, moHidd_PCIDevice_WriteConfigLong);
 436    message.reg = offset & ~0x3;
 437    message.val = data;
 438
 439    OOP_DoMethod(board->aros_board, (OOP_Msg)&message);
 440
 441    AROS_LIBFUNC_EXIT
 442 }
 443
 444
 445
 446 /***************************************************************************
 447
 448     NAME */
 449         AROS_LH2(BOOL, Prm_AddIntServer,
 450
 451 /*  SYNOPSIS */
 452         AROS_LHA(PCIBoard *, board, A0),
 453         AROS_LHA(struct Interrupt *, interrupt, A1),
 454
 455 /*  LOCATION */
 456         struct Library *, PrometheusBase, 14, Prometheus)
 457
 458 /*  FUNCTION
 459
 460     INPUTS
 461
 462     RESULT
 463
 464 ***************************************************************************/
 465 {
 466    AROS_LIBFUNC_INIT
 467
 468    struct LibBase *base = (APTR)PrometheusBase;
 469    BOOL success = TRUE;
 470    HIDDT_IRQ_Handler *aros_irq;
 471    UPINT int_no;
 472
 473    /* Allocate AROS int structure */
 474
 475    if(board == NULL || board->aros_irq != NULL)
 476       success = FALSE;
 477
 478    if(success)
 479    {
 480       aros_irq =
 481          AllocMem(sizeof(HIDDT_IRQ_Handler), MEMF_PUBLIC | MEMF_CLEAR);
 482       if(aros_irq == NULL)
 483          success = FALSE;
 484    }
 485
 486    /* Add AROS int to system */
 487
 488    if(success)
 489    {
 490       OOP_GetAttr(board->aros_board,
 491          base->pcidevice_attr_base + aoHidd_PCIDevice_INTLine, &int_no);
 492       board->aros_irq = aros_irq;
 493       aros_irq->h_Node.ln_Name = interrupt->is_Node.ln_Name;
 494       aros_irq->h_Code = WrapperIRQ;
 495       aros_irq->h_Data = interrupt;
 496
 497       success = HIDD_IRQ_AddHandler(base->irq_hidd, aros_irq, int_no);
 498    }
 499
 500    return success;
 501
 502    AROS_LIBFUNC_EXIT
 503 }
 504
 505
 506
 507 /***************************************************************************
 508
 509     NAME */
 510         AROS_LH2(VOID, Prm_RemIntServer,
 511
 512 /*  SYNOPSIS */
 513         AROS_LHA(PCIBoard *, board, A0),
 514         AROS_LHA(struct Interrupt *, interrupt, A1),
 515
 516 /*  LOCATION */
 517         struct Library *, PrometheusBase, 15, Prometheus)
 518
 519 /*  FUNCTION
 520
 521     INPUTS
 522
 523     RESULT
 524
 525 ***************************************************************************/
 526 {
 527    AROS_LIBFUNC_INIT
 528
 529    struct LibBase *base = (APTR)PrometheusBase;
 530
 531    if(board != NULL)
 532    {
 533       HIDD_IRQ_RemHandler(base->irq_hidd, board->aros_irq);
 534       FreeMem(board->aros_irq, sizeof(HIDDT_IRQ_Handler));
 535       board->aros_irq = NULL;
 536    }
 537
 538    return;
 539
 540    AROS_LIBFUNC_EXIT
 541 }
 542
 543
 544
 545 /***************************************************************************
 546
 547     NAME */
 548         AROS_LH1(APTR, Prm_AllocDMABuffer,
 549
 550 /*  SYNOPSIS */
 551         AROS_LHA(ULONG, size, D0),
 552
 553 /*  LOCATION */
 554         struct Library *, PrometheusBase, 16, Prometheus)
 555
 556 /*  FUNCTION
 557
 558     INPUTS
 559
 560     RESULT
 561
 562 ***************************************************************************/
 563 {
 564    AROS_LIBFUNC_INIT
 565
 566    struct LibBase *base = (APTR)PrometheusBase;
 567    APTR buffer;
 568
 569    if(size != 0)
 570       buffer = AllocMem(size, MEMF_PUBLIC);
 571    else
 572       buffer = NULL;
 573
 574    return buffer;
 575
 576    AROS_LIBFUNC_EXIT
 577 }
 578
 579
 580
 581 /***************************************************************************
 582
 583     NAME */
 584         AROS_LH2(VOID, Prm_FreeDMABuffer,
 585
 586 /*  SYNOPSIS */
 587         AROS_LHA(APTR, buffer, A0),
 588         AROS_LHA(ULONG, size, D0),
 589
 590 /*  LOCATION */
 591         struct Library *, PrometheusBase, 17, Prometheus)
 592
 593 /*  FUNCTION
 594
 595     INPUTS
 596
 597     RESULT
 598
 599 ***************************************************************************/
 600 {
 601    AROS_LIBFUNC_INIT
 602
 603    struct LibBase *base = (APTR)PrometheusBase;
 604
 605    if(buffer != NULL && size != 0)
 606       FreeMem(buffer, size);
 607
 608    return;
 609
 610    AROS_LIBFUNC_EXIT
 611 }
 612
 613
 614
 615 /***************************************************************************
 616
 617     NAME */
 618         AROS_LH1(APTR, Prm_GetPhysicalAddr,
 619
 620 /*  SYNOPSIS */
 621         AROS_LHA(APTR, address, D0),
 622
 623 /*  LOCATION */
 624         struct Library *, PrometheusBase, 18, Prometheus)
 625
 626 /*  FUNCTION
 627
 628     INPUTS
 629
 630     RESULT
 631
 632 ***************************************************************************/
 633 {
 634    AROS_LIBFUNC_INIT
 635
 636    return address;
 637
 638    AROS_LIBFUNC_EXIT
 639 }
 640
 641
 642
 643 static VOID WrapperIRQ(HIDDT_IRQ_Handler *irq, HIDDT_IRQ_HwInfo *hw_info)
 644 {
 645    struct Interrupt *interrupt;
 646
 647    interrupt = (struct Interrupt *)irq->h_Data;
 648    AROS_UFC2(BOOL, interrupt->is_Code,
 649       AROS_UFCA(APTR, interrupt->is_Data, A1),
 650       AROS_UFCA(APTR, interrupt->is_Code, A5));
 651
 652    return;
 653 }
 654
 655
 656