workbench/devs/networks/intelpro100/expansion.c

   1 /*
   2
   3 Copyright (C) 2004,2005 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 <expansion/pci.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 "expansion_protos.h"
  34
  35
  36 /* Private prototypes */
  37
  38 static UBYTE ByteInHook(struct BusContext *context, ULONG offset);
  39 static VOID ByteOutHook(struct BusContext *context, ULONG offset,
  40    UBYTE value);
  41 static UWORD LEWordInHook(struct BusContext *context, ULONG offset);
  42 static ULONG LELongInHook(struct BusContext *context, ULONG offset);
  43 static VOID LEWordOutHook(struct BusContext *context, ULONG offset,
  44    UWORD value);
  45 static VOID LELongOutHook(struct BusContext *context, ULONG offset,
  46    ULONG value);
  47 static APTR AllocDMAMemHook(struct BusContext *context, UPINT size,
  48    UWORD alignment);
  49 static VOID FreeDMAMemHook(struct BusContext *context, APTR mem);
  50
  51
  52 IMPORT const UWORD product_codes[];
  53
  54
  55 static const struct TagItem unit_tags[] =
  56 {
  57    {IOTAG_ByteIn, (UPINT)ByteInHook},
  58    {IOTAG_ByteOut, (UPINT)ByteOutHook},
  59    {IOTAG_LEWordIn, (UPINT)LEWordInHook},
  60    {IOTAG_LELongIn, (UPINT)LELongInHook},
  61    {IOTAG_LEWordOut, (UPINT)LEWordOutHook},
  62    {IOTAG_LELongOut, (UPINT)LELongOutHook},
  63    {IOTAG_AllocDMAMem, (UPINT)AllocDMAMemHook},
  64    {IOTAG_FreeDMAMem, (UPINT)FreeDMAMemHook},
  65    {TAG_END, 0}
  66 };
  67
  68
  69 /****i* intelpro100.device/GetExpansionCount *******************************
  70 *
  71 *   NAME
  72 *       GetExpansionCount -- Get the number of compatible PCI Cards.
  73 *
  74 *   SYNOPSIS
  75 *       count = GetExpansionCount()
  76 *
  77 *       ULONG GetExpansionCount();
  78 *
  79 ****************************************************************************
  80 *
  81 */
  82
  83 ULONG GetExpansionCount(struct DevBase *base)
  84 {
  85    ULONG count = 0;
  86    struct PCIDevice *card;
  87
  88    if(base->i_pci != NULL)
  89    {
  90       while((card =
  91          base->i_pci->FindDeviceTags(FDT_CandidateList, product_codes,
  92          FDT_Index, count, TAG_END)) != NULL)
  93       {
  94          base->i_pci->FreeDevice(card);
  95          count++;
  96       }
  97    }
  98
  99    return count;
 100 }
 101
 102
 103
 104 /****i* intelpro100.device/AllocExpansionCard ******************************
 105 *
 106 *   NAME
 107 *       AllocExpansionCard -- Take control of a card.
 108 *
 109 *   SYNOPSIS
 110 *       context = AllocExpansionCard(index)
 111 *
 112 *       struct BusContext *AllocExpansionCard(ULONG);
 113 *
 114 ****************************************************************************
 115 *
 116 */
 117
 118 struct BusContext *AllocExpansionCard(ULONG index, struct DevBase *base)
 119 {
 120    BOOL success = TRUE;
 121    struct BusContext *context;
 122    struct PCIDevice *card = NULL;
 123    struct PCIResourceRange *io_range = NULL;
 124
 125    /* Find a compatible card */
 126
 127    context = AllocMem(sizeof(struct BusContext), MEMF_PUBLIC | MEMF_CLEAR);
 128    if(context == NULL)
 129       success = FALSE;
 130
 131    if(success)
 132    {
 133       context->card = card =
 134          base->i_pci->FindDeviceTags(FDT_CandidateList, product_codes,
 135          FDT_Index, index, TAG_END);
 136       if(card == NULL)
 137          success = FALSE;
 138    }
 139
 140    if(success)
 141       success = card->Lock(PCI_LOCK_EXCLUSIVE);
 142
 143    if(success)
 144    {
 145       context->have_card = TRUE;
 146 /*      card->SetEndian(PCI_MODE_REVERSE_ENDIAN);*/
 147       io_range = card->GetResourceRange(BAR_NO);
 148       context->io_base = io_range->BaseAddress;
 149       card->FreeResourceRange(io_range);
 150       context->unit_tags = unit_tags;
 151    }
 152
 153    if(!success)
 154    {
 155       FreeExpansionCard(context, base);
 156       context = NULL;
 157    }
 158
 159    return context;
 160 }
 161
 162
 163
 164 /****i* intelpro100.device/FreeExpansionCard *******************************
 165 *
 166 *   NAME
 167 *       FreeExpansionCard -- Release a card.
 168 *
 169 *   SYNOPSIS
 170 *       FreeExpansionCard(context)
 171 *
 172 *       VOID FreeExpansionCard(struct BusContext *);
 173 *
 174 ****************************************************************************
 175 *
 176 */
 177
 178 VOID FreeExpansionCard(struct BusContext *context, struct DevBase *base)
 179 {
 180    struct PCIDevice *card;
 181
 182    if(context != NULL)
 183    {
 184       card = context->card;
 185       if(card != NULL)
 186       {
 187          if(context->have_card)
 188             card->Unlock();
 189          base->i_pci->FreeDevice(card);
 190          FreeMem(context, sizeof(struct BusContext));
 191       }
 192    }
 193
 194    return;
 195 }
 196
 197
 198
 199 /****i* intelpro100.device/AddExpansionIntServer ***************************
 200 *
 201 *   NAME
 202 *       AddExpansionIntServer
 203 *
 204 *   SYNOPSIS
 205 *       context = AddExpansionIntServer(index)
 206 *
 207 *       struct BusContext *AddExpansionIntServer(ULONG);
 208 *
 209 ****************************************************************************
 210 *
 211 */
 212
 213 BOOL AddExpansionIntServer(APTR card, struct Interrupt *interrupt,
 214    struct DevBase *base)
 215 {
 216    return AddIntServer(((struct PCIDevice *)card)->MapInterrupt(),
 217       interrupt);
 218 }
 219
 220
 221
 222 /****i* intelpro100.device/RemExpansionIntServer ***************************
 223 *
 224 *   NAME
 225 *       RemExpansionIntServer
 226 *
 227 *   SYNOPSIS
 228 *       RemExpansionIntServer()
 229 *
 230 *       VOID RemExpansionIntServer(ULONG);
 231 *
 232 ****************************************************************************
 233 *
 234 */
 235
 236 VOID RemExpansionIntServer(APTR card, struct Interrupt *interrupt,
 237    struct DevBase *base)
 238 {
 239    RemIntServer(((struct PCIDevice *)card)->MapInterrupt(), interrupt);
 240
 241    return;
 242 }
 243
 244
 245
 246 /****i* intelpro100.device/ByteInHook **************************************
 247 *
 248 *   NAME
 249 *       ByteInHook
 250 *
 251 *   SYNOPSIS
 252 *       value = ByteInHook(context, offset)
 253 *
 254 *       UBYTE ByteInHook(struct BusContext *, ULONG);
 255 *
 256 ****************************************************************************
 257 *
 258 */
 259
 260 static UBYTE ByteInHook(struct BusContext *context, ULONG offset)
 261 {
 262    struct PCIDevice *card;
 263
 264    card = context->card;
 265    return card->InWord(context->io_base + offset);
 266 }
 267
 268
 269
 270 /****i* intelpro100.device/ByteOutHook *************************************
 271 *
 272 *   NAME
 273 *       ByteOutHook
 274 *
 275 *   SYNOPSIS
 276 *       ByteOutHook(context, offset, value)
 277 *
 278 *       VOID ByteOutHook(struct BusContext *, ULONG, UBYTE);
 279 *
 280 ****************************************************************************
 281 *
 282 */
 283
 284 static VOID ByteOutHook(struct BusContext *context, ULONG offset,
 285    UBYTE value)
 286 {
 287    struct PCIDevice *card;
 288
 289    card = context->card;
 290    card->OutByte(context->io_base + offset, value);
 291
 292    return;
 293 }
 294
 295
 296
 297 /****i* intelpro100.device/LEWordInHook ************************************
 298 *
 299 *   NAME
 300 *       LEWordInHook
 301 *
 302 *   SYNOPSIS
 303 *       value = LEWordInHook(context, offset)
 304 *
 305 *       UWORD LEWordInHook(struct BusContext *, ULONG);
 306 *
 307 ****************************************************************************
 308 *
 309 */
 310
 311 static UWORD LEWordInHook(struct BusContext *context, ULONG offset)
 312 {
 313    struct PCIDevice *card;
 314
 315    card = context->card;
 316    return BEWord(card->InWord(context->io_base + offset));
 317 }
 318
 319
 320
 321 /****i* intelpro100.device/LELongInHook ************************************
 322 *
 323 *   NAME
 324 *       LELongInHook
 325 *
 326 *   SYNOPSIS
 327 *       value = LELongInHook(context, offset)
 328 *
 329 *       ULONG LELongInHook(struct BusContext *, ULONG);
 330 *
 331 ****************************************************************************
 332 *
 333 */
 334
 335 static ULONG LELongInHook(struct BusContext *context, ULONG offset)
 336 {
 337    struct PCIDevice *card;
 338
 339    card = context->card;
 340    return BELong(card->InLong(context->io_base + offset));
 341 }
 342
 343
 344
 345 /****i* intelpro100.device/LEWordOutHook ***********************************
 346 *
 347 *   NAME
 348 *       LEWordOutHook
 349 *
 350 *   SYNOPSIS
 351 *       LEWordOutHook(context, offset, value)
 352 *
 353 *       VOID LEWordOutHook(struct BusContext *, ULONG, UWORD);
 354 *
 355 ****************************************************************************
 356 *
 357 */
 358
 359 static VOID LEWordOutHook(struct BusContext *context, ULONG offset,
 360    UWORD value)
 361 {
 362    struct PCIDevice *card;
 363
 364    card = context->card;
 365    card->OutWord(context->io_base + offset, MakeBEWord(value));
 366
 367    return;
 368 }
 369
 370
 371
 372 /****i* intelpro100.device/LELongOutHook ***********************************
 373 *
 374 *   NAME
 375 *       LELongOutHook
 376 *
 377 *   SYNOPSIS
 378 *       LELongOutHook(context, offset, value)
 379 *
 380 *       VOID LELongOutHook(struct BusContext *, ULONG, ULONG);
 381 *
 382 ****************************************************************************
 383 *
 384 */
 385
 386 static VOID LELongOutHook(struct BusContext *context, ULONG offset,
 387    ULONG value)
 388 {
 389    struct PCIDevice *card;
 390
 391    card = context->card;
 392    card->OutLong(context->io_base + offset, MakeBELong(value));
 393
 394    return;
 395 }
 396
 397
 398
 399 /****i* intelpro100.device/AllocDMAMemHook *********************************
 400 *
 401 *   NAME
 402 *       AllocDMAMemHook
 403 *
 404 *   SYNOPSIS
 405 *       mem = AllocDMAMemHook(context, size, alignment)
 406 *
 407 *       APTR AllocDMAMemHook(struct BusContext *, UPINT, UWORD);
 408 *
 409 ****************************************************************************
 410 *
 411 * Alignment currently must be minimum of 8 bytes.
 412 *
 413 */
 414
 415 static APTR AllocDMAMemHook(struct BusContext *context, UPINT size,
 416    UWORD alignment)
 417 {
 418    struct DevBase *base;
 419    APTR mem = NULL, original_mem;
 420
 421    base = context->device;
 422    size += 2 * sizeof(APTR) + alignment;
 423    original_mem = AllocMem(size, MEMF_PUBLIC);
 424    if(original_mem != NULL)
 425    {
 426       mem = (APTR)((UPINT)(original_mem + 2 * sizeof(APTR) + alignment - 1)
 427          & ~(alignment - 1));
 428       *((APTR *)mem - 1) = original_mem;
 429       *((UPINT *)mem - 2) = size;
 430    }
 431
 432    return mem;
 433 }
 434
 435
 436
 437 /****i* intelpro100.device/FreeDMAMemHook **********************************
 438 *
 439 *   NAME
 440 *       FreeDMAMemHook
 441 *
 442 *   SYNOPSIS
 443 *       FreeDMAMemHook(context, mem)
 444 *
 445 *       VOID FreeDMAMemHook(struct BusContext *, APTR);
 446 *
 447 ****************************************************************************
 448 *
 449 */
 450
 451 static VOID FreeDMAMemHook(struct BusContext *context, APTR mem)
 452 {
 453    struct DevBase *base;
 454
 455    base = context->device;
 456    if(mem != NULL)
 457          FreeMem(*((APTR *)mem - 1), *((UPINT *)mem - 2));
 458
 459    return;
 460 }
 461
 462
 463