workbench/devs/networks/atheros5000/pci.c

   1 /*
   2
   3 Copyright (C) 2004-2013 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 "expansion_protos.h"
  36 #include "openpci_protos.h"
  37 #include "unit_protos.h"
  38
  39
  40 /* Private prototypes */
  41
  42 static struct DevUnit *FindPCIUnit(ULONG index, struct DevBase *base);
  43 static struct DevUnit *CreatePCIUnit(ULONG index, struct DevBase *base);
  44 static struct BusContext *AllocCard(ULONG index, struct DevBase *base);
  45 static VOID FreeCard(struct BusContext *context, struct DevBase *base);
  46 static BOOL AddPCIIntServer(APTR card, struct Interrupt *interrupt,
  47    struct DevBase *base);
  48 static VOID RemPCIIntServer(APTR card, struct Interrupt *interrupt,
  49    struct DevBase *base);
  50 BOOL IsCardCompatible(UWORD vendor_id, UWORD product_id,
  51    struct DevBase *base);
  52 static APTR AllocDMAMemHook(struct BusContext *context, UPINT size,
  53    UWORD alignment);
  54 static VOID FreeDMAMemHook(struct BusContext *context, APTR mem);
  55
  56
  57 const UWORD product_codes[] =
  58 {
  59    0x10b7, 0x0013,
  60    0x168c, 0x0007,
  61    0x168c, 0x0012,
  62    0x168c, 0x0013,
  63    0x168c, 0x0015,
  64    0x168c, 0x0016,
  65    0x168c, 0x0017,
  66    0x168c, 0x0018,
  67    0x168c, 0x0019,
  68    0x168c, 0x001a,
  69    0x168c, 0x001b,
  70    0x168c, 0x001c,
  71    0x168c, 0x001d,
  72    0x168c, 0x1014,
  73    0x168c, 0x101a,
  74    0x168c, 0x9013,
  75    0xa727, 0x0013,
  76    0xffff, 0xffff
  77 };
  78
  79
  80 static const struct TagItem unit_tags[] =
  81 {
  82    {IOTAG_AllocDMAMem, (UPINT)AllocDMAMemHook},
  83    {IOTAG_FreeDMAMem, (UPINT)FreeDMAMemHook},
  84    {TAG_END, 0}
  85 };
  86
  87
  88 /****i* atheros5000.device/GetPCICount *************************************
  89 *
  90 *   NAME
  91 *       GetPCICount -- Get the number of compatible PCI Cards.
  92 *
  93 *   SYNOPSIS
  94 *       count = GetPCICount()
  95 *
  96 *       ULONG GetPCICount();
  97 *
  98 ****************************************************************************
  99 *
 100 */
 101
 102 ULONG GetPCICount(struct DevBase *base)
 103 {
 104    ULONG count = 0;
 105
 106 #if !(defined(__MORPHOS__) || defined(__amigaos4__))
 107    if(base->prometheus_base != NULL)
 108       count = GetPrometheusCount(base);
 109 #endif
 110 #ifdef __amigaos4__
 111    if(base->expansion_base != NULL)
 112       count = GetExpansionCount(base);
 113 #endif
 114 #ifdef __MORPHOS__
 115    if(base->openpci_base != NULL)
 116       count = GetOpenPCICount(base);
 117 #endif
 118
 119    return count;
 120 }
 121
 122
 123
 124 /****i* atheros5000.device/GetPCIUnit **************************************
 125 *
 126 *   NAME
 127 *       GetPCIUnit -- Get a unit by number.
 128 *
 129 *   SYNOPSIS
 130 *       unit = GetPCIUnit(index)
 131 *
 132 *       struct DevUnit *GetPCIUnit(ULONG);
 133 *
 134 ****************************************************************************
 135 *
 136 */
 137
 138 struct DevUnit *GetPCIUnit(ULONG index, struct DevBase *base)
 139 {
 140    struct DevUnit *unit;
 141
 142    unit = FindPCIUnit(index, base);
 143
 144    if(unit == NULL)
 145    {
 146       unit = CreatePCIUnit(index, base);
 147       if(unit != NULL)
 148       {
 149          AddTail((APTR)&base->pci_units, (APTR)unit);
 150       }
 151    }
 152
 153    return unit;
 154 }
 155
 156
 157
 158 /****i* atheros5000.device/FindPCIUnit *************************************
 159 *
 160 *   NAME
 161 *       FindPCIUnit -- Find a unit by number.
 162 *
 163 *   SYNOPSIS
 164 *       unit = FindPCIUnit(index)
 165 *
 166 *       struct DevUnit *FindPCIUnit(ULONG);
 167 *
 168 ****************************************************************************
 169 *
 170 */
 171
 172 static struct DevUnit *FindPCIUnit(ULONG index, struct DevBase *base)
 173 {
 174    struct DevUnit *unit, *tail;
 175    BOOL found = FALSE;
 176
 177    unit = (APTR)base->pci_units.mlh_Head;
 178    tail = (APTR)&base->pci_units.mlh_Tail;
 179
 180    while(unit != tail && !found)
 181    {
 182       if(unit->index == index)
 183          found = TRUE;
 184       else
 185          unit = (APTR)unit->node.mln_Succ;
 186    }
 187
 188    if(!found)
 189       unit = NULL;
 190
 191    return unit;
 192 }
 193
 194
 195
 196 /****i* atheros5000.device/CreatePCIUnit ***********************************
 197 *
 198 *   NAME
 199 *       CreatePCIUnit -- Create a unit.
 200 *
 201 *   SYNOPSIS
 202 *       unit = CreatePCIUnit(index)
 203 *
 204 *       struct DevUnit *CreatePCIUnit(ULONG);
 205 *
 206 *   FUNCTION
 207 *       Creates a PCI new unit.
 208 *
 209 ****************************************************************************
 210 *
 211 */
 212
 213 static struct DevUnit *CreatePCIUnit(ULONG index, struct DevBase *base)
 214 {
 215    BOOL success = TRUE;
 216    struct BusContext *context;
 217    struct DevUnit *unit = NULL;
 218
 219    context = AllocCard(index, base);
 220    if(context == NULL)
 221       success = FALSE;
 222
 223    if(success)
 224    {
 225       if(context->unit_tags == NULL)
 226          context->unit_tags = unit_tags;
 227
 228       context->device = base;
 229       context->unit = unit =
 230          CreateUnit(index, (APTR)context->io_base, context->id, context,
 231             context->unit_tags, 0, base);
 232       if(unit == NULL)
 233          success = FALSE;
 234    }
 235
 236    /* Add interrupt */
 237
 238    if(success)
 239    {
 240       if(!(WrapInt(&unit->status_int, base)
 241          && WrapInt(&unit->rx_int, base)
 242          && WrapInt(&unit->tx_int, base)
 243          && WrapInt(&unit->tx_end_int, base)
 244          && WrapInt(&unit->mgmt_int, base)
 245          && WrapInt(&unit->mgmt_end_int, base)
 246          && WrapInt(&unit->reset_handler, base)))
 247          success = FALSE;
 248    }
 249
 250    /* Add hardware interrupt and reset handler */
 251
 252    if(success)
 253    {
 254       if(AddPCIIntServer(context->card, &unit->status_int, base))
 255          unit->flags |= UNITF_INTADDED;
 256       else
 257          success = FALSE;
 258
 259 #if defined(__amigaos4__) || defined(__AROS__)
 260       if(AddResetCallback(&unit->reset_handler))
 261          unit->flags |= UNITF_RESETADDED;
 262       else
 263          success = FALSE;
 264 #endif
 265    }
 266
 267    if(!success)
 268    {
 269       if(context != NULL)
 270       {
 271          DeleteUnit(context->unit, base);
 272          FreeCard(context, base);
 273       }
 274       unit = NULL;
 275    }
 276
 277    return unit;
 278 }
 279
 280
 281
 282 /****i* atheros5000.device/DeletePCIUnit ***********************************
 283 *
 284 *   NAME
 285 *       DeletePCIUnit -- Delete a unit.
 286 *
 287 *   SYNOPSIS
 288 *       DeletePCIUnit(unit)
 289 *
 290 *       VOID DeletePCIUnit(struct DevUnit *);
 291 *
 292 *   FUNCTION
 293 *       Deletes a unit.
 294 *
 295 *   INPUTS
 296 *       unit - Device unit (can be NULL).
 297 *
 298 *   RESULT
 299 *       None.
 300 *
 301 ****************************************************************************
 302 *
 303 */
 304
 305 VOID DeletePCIUnit(struct DevUnit *unit, struct DevBase *base)
 306 {
 307    struct BusContext *context;
 308
 309    if(unit != NULL)
 310    {
 311       context = unit->card;
 312 #if defined(__amigaos4__) || defined(__AROS__)
 313       if((unit->flags & UNITF_RESETADDED) != 0)
 314          RemResetCallback(&unit->reset_handler);
 315 #endif
 316       if((unit->flags & UNITF_INTADDED) != 0)
 317          RemPCIIntServer(context->card, &unit->status_int, base);
 318       UnwrapInt(&unit->reset_handler, base);
 319       UnwrapInt(&unit->mgmt_end_int, base);
 320       UnwrapInt(&unit->mgmt_int, base);
 321       UnwrapInt(&unit->tx_end_int, base);
 322       UnwrapInt(&unit->tx_int, base);
 323       UnwrapInt(&unit->rx_int, base);
 324       UnwrapInt(&unit->status_int, base);
 325       DeleteUnit(unit, base);
 326       FreeCard(context, base);
 327    }
 328
 329    return;
 330 }
 331
 332
 333
 334 /****i* atheros5000.device/AllocCard ***************************************
 335 *
 336 *   NAME
 337 *       AllocCard -- Get card from system.
 338 *
 339 *   SYNOPSIS
 340 *       context = AllocCard(index)
 341 *
 342 *       struct BusContext *AllocCard(ULONG);
 343 *
 344 ****************************************************************************
 345 *
 346 */
 347
 348 static struct BusContext *AllocCard(ULONG index, struct DevBase *base)
 349 {
 350    struct BusContext *context;
 351
 352 #if !(defined(__MORPHOS__) || defined(__amigaos4__))
 353    if(base->prometheus_base != NULL)
 354       context = AllocPrometheusCard(index, base);
 355 #endif
 356 #ifdef __amigaos4__
 357    if(base->expansion_base != NULL)
 358       context = AllocExpansionCard(index, base);
 359 #endif
 360 #ifdef __MORPHOS__
 361    if(base->openpci_base != NULL)
 362       context = AllocOpenPCICard(index, base);
 363 #endif
 364
 365    return context;
 366 }
 367
 368
 369
 370 /****i* atheros5000.device/FreeCard ****************************************
 371 *
 372 *   NAME
 373 *       FreeCard
 374 *
 375 *   SYNOPSIS
 376 *       FreeCard(context)
 377 *
 378 *       VOID FreeCard(struct BusContext *);
 379 *
 380 ****************************************************************************
 381 *
 382 */
 383
 384 static VOID FreeCard(struct BusContext *context, struct DevBase *base)
 385 {
 386
 387    if(context != NULL)
 388    {
 389 #if !(defined(__MORPHOS__) || defined(__amigaos4__))
 390       if(base->prometheus_base != NULL)
 391          FreePrometheusCard(context, base);
 392 #endif
 393 #ifdef __amigaos4__
 394       if(base->expansion_base != NULL)
 395          FreeExpansionCard(context, base);
 396 #endif
 397 #ifdef __MORPHOS__
 398       if(base->openpci_base != NULL)
 399          FreeOpenPCICard(context, base);
 400 #endif
 401    }
 402
 403    return;
 404 }
 405
 406
 407
 408 /****i* atheros5000.device/AddPCIIntServer *********************************
 409 *
 410 *   NAME
 411 *       AddPCIIntServer
 412 *
 413 *   SYNOPSIS
 414 *       success = AddPCIIntServer(card, interrupt)
 415 *
 416 *       BOOL AddPCIIntServer(APTR, struct Interrupt *);
 417 *
 418 ****************************************************************************
 419 *
 420 */
 421
 422 static BOOL AddPCIIntServer(APTR card, struct Interrupt *interrupt,
 423    struct DevBase *base)
 424 {
 425    BOOL success;
 426
 427 #if !(defined(__MORPHOS__) || defined(__amigaos4__))
 428    if(base->prometheus_base != NULL)
 429       success = AddPrometheusIntServer(card, interrupt, base);
 430 #endif
 431 #ifdef __amigaos4__
 432    if(base->expansion_base != NULL)
 433       success = AddExpansionIntServer(card, interrupt, base);
 434 #endif
 435 #ifdef __MORPHOS__
 436    if(base->openpci_base != NULL)
 437       success = AddOpenPCIIntServer(card, interrupt, base);
 438 #endif
 439
 440    return success;
 441 }
 442
 443
 444
 445 /****i* atheros5000.device/RemPCIIntServer *********************************
 446 *
 447 *   NAME
 448 *       RemPCIIntServer
 449 *
 450 *   SYNOPSIS
 451 *       RemPCIIntServer(card, interrupt)
 452 *
 453 *       VOID RemPCIIntServer(APTR, struct Interrupt *);
 454 *
 455 ****************************************************************************
 456 *
 457 */
 458
 459 static VOID RemPCIIntServer(APTR card, struct Interrupt *interrupt,
 460    struct DevBase *base)
 461 {
 462 #if !(defined(__MORPHOS__) || defined(__amigaos4__))
 463    if(base->prometheus_base != NULL)
 464       RemPrometheusIntServer(card, interrupt, base);
 465 #endif
 466 #ifdef __amigaos4__
 467    if(base->expansion_base != NULL)
 468       RemExpansionIntServer(card, interrupt, base);
 469 #endif
 470 #ifdef __MORPHOS__
 471    if(base->openpci_base != NULL)
 472       RemOpenPCIIntServer(card, interrupt, base);
 473 #endif
 474
 475    return;
 476 }
 477
 478
 479
 480 /****i* atheros5000.device/IsCardCompatible ********************************
 481 *
 482 *   NAME
 483 *       IsCardCompatible
 484 *
 485 *   SYNOPSIS
 486 *       compatible = IsCardCompatible(context)
 487 *
 488 *       BOOL IsCardCompatible(struct BusContext *);
 489 *
 490 ****************************************************************************
 491 *
 492 */
 493
 494 BOOL IsCardCompatible(UWORD vendor_id, UWORD product_id,
 495    struct DevBase *base)
 496 {
 497    BOOL compatible = FALSE;
 498    const UWORD *p;
 499
 500    for(p = product_codes; p[0] != 0xffff; p += 2)
 501    {
 502       if(p[0] == vendor_id && p[1] == product_id)
 503          compatible = TRUE;
 504    }
 505
 506    return compatible;
 507 }
 508
 509
 510
 511 /****i* atheros5000.device/AllocDMAMemHook *********************************
 512 *
 513 *   NAME
 514 *       AllocDMAMemHook
 515 *
 516 *   SYNOPSIS
 517 *       mem = AllocDMAMemHook(context, size, alignment)
 518 *
 519 *       APTR AllocDMAMemHook(struct BusContext *, UPINT, UWORD);
 520 *
 521 ****************************************************************************
 522 *
 523 * Alignment currently must be minimum of 8 bytes.
 524 *
 525 */
 526
 527 static APTR AllocDMAMemHook(struct BusContext *context, UPINT size,
 528    UWORD alignment)
 529 {
 530    struct DevBase *base;
 531    APTR mem = NULL, original_mem;
 532
 533    base = context->device;
 534    size += 2 * sizeof(APTR) + alignment;
 535 #if !(defined(__MORPHOS__) || defined(__amigaos4__))
 536    if(base->prometheus_base != NULL)
 537       original_mem = AllocPrometheusDMAMem(size, base);
 538    else
 539 #endif
 540       original_mem = AllocMem(size, MEMF_PUBLIC);
 541    if(original_mem != NULL)
 542    {
 543       mem = (APTR)((UPINT)(original_mem + 2 * sizeof(APTR) + alignment - 1)
 544          & ~(alignment - 1));
 545       *((APTR *)mem - 1) = original_mem;
 546       *((UPINT *)mem - 2) = size;
 547    }
 548
 549    return mem;
 550 }
 551
 552
 553
 554 /****i* atheros5000.device/FreeDMAMemHook **********************************
 555 *
 556 *   NAME
 557 *       FreeDMAMemHook
 558 *
 559 *   SYNOPSIS
 560 *       FreeDMAMemHook(context, mem)
 561 *
 562 *       VOID FreeDMAMemHook(struct BusContext *, APTR);
 563 *
 564 ****************************************************************************
 565 *
 566 */
 567
 568 static VOID FreeDMAMemHook(struct BusContext *context, APTR mem)
 569 {
 570    struct DevBase *base;
 571
 572    base = context->device;
 573    if(mem != NULL)
 574    {
 575 #if !(defined(__MORPHOS__) || defined(__amigaos4__))
 576       if(base->prometheus_base != NULL)
 577          FreePrometheusDMAMem(*((APTR *)mem - 1), *((UPINT *)mem - 2),
 578             base);
 579       else
 580 #endif
 581          FreeMem(*((APTR *)mem - 1), *((UPINT *)mem - 2));
 582    }
 583
 584    return;
 585 }
 586
 587
 588