workbench/devs/networks/prism2/prometheus.c

   1 /*
   2
   3 File: prometheus.c
   4 Author: Neil Cafferkey
   5 Copyright (C) 2004,2005 Neil Cafferkey
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15 General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  20 MA 02111-1307, USA.
  21
  22 */
  23
  24
  25 #include <exec/types.h>
  26 #include <libraries/prometheus.h>
  27
  28 #include <proto/exec.h>
  29 #include <proto/prometheus.h>
  30
  31 #include "device.h"
  32 #include "pci.h"
  33
  34 #include "pci_protos.h"
  35 #include "prometheus_protos.h"
  36
  37
  38 #define RETRY_COUNT 15
  39
  40 #define PLX9052_INTS 0x4c
  41 #define PLX9052_CNTRL 0x50
  42
  43 #define PLX9052_CNTRLB_PCI21   14
  44 #define PLX9052_CNTRLB_RETRIES 19
  45
  46 #define PLX9052_CNTRLF_PCI21   (1 << PLX9052_CNTRLB_PCI21)
  47 #define PLX9052_CNTRLF_RETRIES (0xf << PLX9052_CNTRLB_RETRIES)
  48
  49
  50 /****i* prism2.device/GetPrometheusCount ***********************************
  51 *
  52 *   NAME
  53 *       GetPrometheusCount
  54 *
  55 *   SYNOPSIS
  56 *       count = GetPrometheusCount()
  57 *
  58 *       ULONG GetPrometheusCount();
  59 *
  60 ****************************************************************************
  61 *
  62 */
  63
  64 ULONG GetPrometheusCount(struct DevBase *base)
  65 {
  66    ULONG count = 0;
  67    PCIBoard *card = NULL;
  68    UPINT vendor_id, product_id;
  69
  70    while((card = Prm_FindBoardTagList(card, NULL)) != NULL)
  71    {
  72       Prm_GetBoardAttrsTags(card, PRM_Vendor, (UPINT)&vendor_id,
  73          PRM_Device, (UPINT)&product_id, TAG_END);
  74       if(IsCardCompatible(vendor_id, product_id, base))
  75          count++;
  76    }
  77
  78    return count;
  79 }
  80
  81
  82
  83 /****i* prism2.device/AllocPrometheusCard **********************************
  84 *
  85 *   NAME
  86 *       AllocPrometheusCard -- Create a unit.
  87 *
  88 *   SYNOPSIS
  89 *       context = AllocPrometheusCard(index)
  90 *
  91 *       struct BusContext *AllocPrometheusCard(ULONG);
  92 *
  93 ****************************************************************************
  94 *
  95 */
  96
  97 struct BusContext *AllocPrometheusCard(ULONG index, struct DevBase *base)
  98 {
  99    BOOL success = TRUE;
 100    struct BusContext *context;
 101    PCIBoard *card = NULL;
 102    UWORD i = 0;
 103    UPINT vendor_id, product_id, plx_base;
 104    UBYTE io_range_no;
 105    volatile UBYTE *cor_reg;
 106    ULONG pci_control;
 107
 108    /* Find a compatible card */
 109
 110    context = AllocMem(sizeof(struct BusContext), MEMF_PUBLIC | MEMF_CLEAR);
 111    if(context == NULL)
 112       success = FALSE;
 113
 114    if(success)
 115    {
 116       while(i <= index)
 117       {
 118          card = Prm_FindBoardTagList(card, NULL);
 119          Prm_GetBoardAttrsTags(card, PRM_Vendor, (UPINT)&vendor_id,
 120             PRM_Device, (UPINT)&product_id, TAG_END);
 121          if(IsCardCompatible(vendor_id, product_id, base))
 122             i++;
 123       }
 124
 125       context->card = card;
 126       if(card == NULL)
 127          success = FALSE;
 128    }
 129
 130    if(success)
 131    {
 132       /* Find out what type of Prism II PCI card this is */
 133
 134       context->bus_type = GetBusType(product_id, base);
 135
 136       if(context->bus_type == TMD_BUS)
 137       {
 138          /* Enable the PCCard */
 139
 140          Prm_GetBoardAttrsTags(card, PRM_MemoryAddr1, (UPINT)&cor_reg,
 141             TAG_END);
 142          BYTEOUT((UPINT)cor_reg, COR_VALUE);
 143          io_range_no = 2;
 144       }
 145       else if(context->bus_type == PLX_BUS)
 146       {
 147          /* Enable interrupts on the bridge */
 148
 149          Prm_GetBoardAttrsTags(card, PRM_MemoryAddr1, (UPINT)&plx_base,
 150             TAG_END);
 151          LELONGOUT(plx_base + PLX9052_INTS,
 152             LELONGIN(plx_base + PLX9052_INTS) | (1 << 6));
 153
 154 #ifdef __mc68000
 155          /* Delay PCI retries as long as possible, so that they will
 156             hopefully never occur */
 157
 158          pci_control = LELONGIN(plx_base + PLX9052_CNTRL);
 159          pci_control &= ~(PLX9052_CNTRLF_RETRIES | PLX9052_CNTRLF_PCI21);
 160          pci_control |= RETRY_COUNT << PLX9052_CNTRLB_RETRIES;
 161          LELONGOUT(plx_base + PLX9052_CNTRL, pci_control);
 162 #endif
 163
 164          /* Enable the PCCard */
 165
 166          Prm_GetBoardAttrsTags(card, PRM_MemoryAddr2, (UPINT)&cor_reg,
 167             TAG_END);
 168          cor_reg += 0x3e0;
 169          *cor_reg = COR_VALUE;
 170          io_range_no = 3;
 171       }
 172       else
 173          io_range_no = 0;
 174
 175       /* Get the I/O base of the wireless chip */
 176
 177       Prm_GetBoardAttrsTags(card, PRM_MemoryAddr0 + io_range_no,
 178          (UPINT)&context->io_base, TAG_END);
 179       if(context->io_base == 0)
 180          success = FALSE;
 181    }
 182
 183    /* Lock card */
 184
 185    if(success)
 186    {
 187       if(!Prm_SetBoardAttrsTags(card, PRM_BoardOwner, (UPINT)base, TAG_END))
 188          success = FALSE;
 189    }
 190
 191    if(!success)
 192    {
 193       FreePrometheusCard(context, base);
 194       context = NULL;
 195    }
 196
 197    return context;
 198 }
 199
 200
 201
 202 /****i* prism2.device/FreePrometheusCard ***********************************
 203 *
 204 *   NAME
 205 *       FreePrometheusCard
 206 *
 207 *   SYNOPSIS
 208 *       FreePrometheusCard(context)
 209 *
 210 *       VOID FreePrometheusCard(struct BusContext *);
 211 *
 212 ****************************************************************************
 213 *
 214 */
 215
 216 VOID FreePrometheusCard(struct BusContext *context, struct DevBase *base)
 217 {
 218    PCIBoard *card;
 219    APTR owner;
 220
 221    if(context != NULL)
 222    {
 223       card = context->card;
 224       if(card != NULL)
 225       {
 226          /* Unlock board */
 227
 228          Prm_GetBoardAttrsTags(card, PRM_BoardOwner, (UPINT)&owner,
 229             TAG_END);
 230          if(owner == base)
 231             Prm_SetBoardAttrsTags(card, PRM_BoardOwner, NULL, TAG_END);
 232       }
 233
 234       FreeMem(context, sizeof(struct BusContext));
 235    }
 236
 237    return;
 238 }
 239
 240
 241
 242 /****i* prism2.device/AddPrometheusIntServer *******************************
 243 *
 244 *   NAME
 245 *       AddPrometheusIntServer
 246 *
 247 *   SYNOPSIS
 248 *       context = AddPrometheusIntServer(index)
 249 *
 250 *       struct BusContext *AddPrometheusIntServer(ULONG);
 251 *
 252 ****************************************************************************
 253 *
 254 */
 255
 256 BOOL AddPrometheusIntServer(APTR card, struct Interrupt *interrupt,
 257    struct DevBase *base)
 258 {
 259    return Prm_AddIntServer(card, interrupt);
 260 }
 261
 262
 263
 264 /****i* prism2.device/RemPrometheusIntServer *******************************
 265 *
 266 *   NAME
 267 *       RemPrometheusIntServer
 268 *
 269 *   SYNOPSIS
 270 *       RemPrometheusIntServer()
 271 *
 272 *       VOID RemPrometheusIntServer(ULONG);
 273 *
 274 ****************************************************************************
 275 *
 276 */
 277
 278 VOID RemPrometheusIntServer(APTR card, struct Interrupt *interrupt,
 279    struct DevBase *base)
 280 {
 281    Prm_RemIntServer(card, interrupt);
 282
 283    return;
 284 }
 285
 286
 287