workbench/devs/networks/atheros5000/prometheus.c

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