workbench/devs/networks/etherlink3/prometheus.c

   1 /*
   2
   3 Copyright (C) 2004-2011 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 <libraries/prometheus.h>
  25
  26 #include <proto/exec.h>
  27 #include <proto/prometheus.h>
  28
  29 #include "device.h"
  30 #include "pci.h"
  31
  32 #include "pci_protos.h"
  33 #include "prometheus_protos.h"
  34
  35
  36 /****i* etherlink3.device/GetPrometheusCount *******************************
  37 *
  38 *   NAME
  39 *       GetPrometheusCount
  40 *
  41 *   SYNOPSIS
  42 *       count = GetPrometheusCount()
  43 *
  44 *       ULONG GetPrometheusCount();
  45 *
  46 ****************************************************************************
  47 *
  48 */
  49
  50 ULONG GetPrometheusCount(struct DevBase *base)
  51 {
  52    ULONG count = 0;
  53    PCIBoard *card = NULL;
  54    UPINT vendor_id, product_id;
  55
  56    while((card = Prm_FindBoardTagList(card, NULL)) != NULL)
  57    {
  58       Prm_GetBoardAttrsTags(card, PRM_Vendor, (UPINT)&vendor_id,
  59          PRM_Device, (UPINT)&product_id, TAG_END);
  60       if(IsCardCompatible(vendor_id, product_id, base))
  61          count++;
  62    }
  63
  64    return count;
  65 }
  66
  67
  68
  69 /****i* etherlink3.device/AllocPrometheusCard ******************************
  70 *
  71 *   NAME
  72 *       AllocPrometheusCard -- Take control of a card.
  73 *
  74 *   SYNOPSIS
  75 *       context = AllocPrometheusCard(index)
  76 *
  77 *       struct BusContext *AllocPrometheusCard(ULONG);
  78 *
  79 ****************************************************************************
  80 *
  81 */
  82
  83 struct BusContext *AllocPrometheusCard(ULONG index, struct DevBase *base)
  84 {
  85    BOOL success = TRUE;
  86    struct BusContext *context;
  87    PCIBoard *card = NULL;
  88    UWORD i = 0;
  89    UPINT vendor_id, product_id;
  90
  91    /* Find a compatible card */
  92
  93    context = AllocMem(sizeof(struct BusContext), MEMF_PUBLIC | MEMF_CLEAR);
  94    if(context == NULL)
  95       success = FALSE;
  96
  97    if(success)
  98    {
  99       while(i <= index)
 100       {
 101          card = Prm_FindBoardTagList(card, NULL);
 102          Prm_GetBoardAttrsTags(card, PRM_Vendor, (UPINT)&vendor_id,
 103             PRM_Device, (UPINT)&product_id, TAG_END);
 104          if(IsCardCompatible(vendor_id, product_id, base))
 105             i++;
 106       }
 107
 108       context->card = card;
 109       if(card == NULL)
 110          success = FALSE;
 111    }
 112
 113    /* Get base address and generation */
 114
 115    if(success)
 116    {
 117       Prm_GetBoardAttrsTags(card,
 118          PRM_MemoryAddr0 + BAR_NO, (UPINT)&context->io_base, TAG_END);
 119       if(context->io_base == 0)
 120          success = FALSE;
 121       context->generation = GetGeneration(product_id, base);
 122    }
 123
 124    /* Lock card */
 125
 126    if(success)
 127    {
 128       if(!Prm_SetBoardAttrsTags(card, PRM_BoardOwner, (UPINT)base, TAG_END))
 129          success = FALSE;
 130    }
 131
 132    if(!success)
 133    {
 134       FreePrometheusCard(context, base);
 135       context = NULL;
 136    }
 137
 138    return context;
 139 }
 140
 141
 142
 143 /****i* etherlink3.device/FreePrometheusCard *******************************
 144 *
 145 *   NAME
 146 *       FreePrometheusCard -- Release a card.
 147 *
 148 *   SYNOPSIS
 149 *       FreePrometheusCard(context)
 150 *
 151 *       VOID FreePrometheusCard(struct BusContext *);
 152 *
 153 ****************************************************************************
 154 *
 155 */
 156
 157 VOID FreePrometheusCard(struct BusContext *context, struct DevBase *base)
 158 {
 159    PCIBoard *card;
 160    APTR owner;
 161
 162    if(context != NULL)
 163    {
 164       card = context->card;
 165       if(card != NULL)
 166       {
 167          /* Unlock board */
 168
 169          Prm_GetBoardAttrsTags(card, PRM_BoardOwner, (UPINT)&owner,
 170             TAG_END);
 171          if(owner == base)
 172             Prm_SetBoardAttrsTags(card, PRM_BoardOwner, NULL, TAG_END);
 173       }
 174
 175       FreeMem(context, sizeof(struct BusContext));
 176    }
 177
 178    return;
 179 }
 180
 181
 182
 183 /****i* etherlink3.device/AddPrometheusIntServer ***************************
 184 *
 185 *   NAME
 186 *       AddPrometheusIntServer
 187 *
 188 *   SYNOPSIS
 189 *       success = AddPrometheusIntServer(card, interrupt)
 190 *
 191 *       BOOL AddPrometheusIntServer(APTR, struct Interrupt *);
 192 *
 193 ****************************************************************************
 194 *
 195 */
 196
 197 BOOL AddPrometheusIntServer(APTR card, struct Interrupt *interrupt,
 198    struct DevBase *base)
 199 {
 200    return Prm_AddIntServer(card, interrupt);
 201 }
 202
 203
 204
 205 /****i* etherlink3.device/RemPrometheusIntServer ***************************
 206 *
 207 *   NAME
 208 *       RemPrometheusIntServer
 209 *
 210 *   SYNOPSIS
 211 *       RemPrometheusIntServer(card, interrupt)
 212 *
 213 *       VOID RemPrometheusIntServer(APTR, struct Interrupt *);
 214 *
 215 ****************************************************************************
 216 *
 217 */
 218
 219 VOID RemPrometheusIntServer(APTR card, struct Interrupt *interrupt,
 220    struct DevBase *base)
 221 {
 222    Prm_RemIntServer(card, interrupt);
 223
 224    return;
 225 }
 226
 227
 228
 229 /****i* etherlink3.device/AllocPrometheusDMAMem ****************************
 230 *
 231 *   NAME
 232 *       AllocPrometheusDMAMem
 233 *
 234 *   SYNOPSIS
 235 *       mem = AllocPrometheusDMAMem(context, size, alignment)
 236 *
 237 *       APTR AllocPrometheusDMAMem(struct BusContext *, UPINT, UWORD);
 238 *
 239 ****************************************************************************
 240 *
 241 * Alignment currently must be minimum of 8 bytes.
 242 *
 243 */
 244
 245 APTR AllocPrometheusDMAMem(UPINT size, struct DevBase *base)
 246 {
 247    return Prm_AllocDMABuffer(size);
 248 }
 249
 250
 251
 252 /****i* etherlink3.device/FreePrometheusDMAMem *****************************
 253 *
 254 *   NAME
 255 *       FreePrometheusDMAMem
 256 *
 257 *   SYNOPSIS
 258 *       FreePrometheusDMAMem(context, mem)
 259 *
 260 *       VOID FreePrometheusDMAMem(struct BusContext *, APTR);
 261 *
 262 ****************************************************************************
 263 *
 264 */
 265
 266 VOID FreePrometheusDMAMem(APTR mem, UPINT size, struct DevBase *base)
 267 {
 268    Prm_FreeDMABuffer(mem, size);
 269
 270    return;
 271 }
 272
 273
 274