workbench/devs/networks/prism2/cybpci.c

   1 /*
   2
   3 Copyright (C) 2004-2012 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/cybpci.h>
  25
  26 #include <proto/exec.h>
  27 #include <proto/cybpci.h>
  28
  29 #include "pci.h"
  30 #include "plx9052.h"
  31
  32 #include "pci_protos.h"
  33 #include "cybpci_protos.h"
  34
  35
  36 /****i* prism2.device/GetCybPCICount ***************************************
  37 *
  38 *   NAME
  39 *       GetCybPCICount
  40 *
  41 *   SYNOPSIS
  42 *       count = GetCybPCICount()
  43 *
  44 *       ULONG GetCybPCICount();
  45 *
  46 ****************************************************************************
  47 *
  48 */
  49
  50 ULONG GetCybPCICount(struct DevBase *base)
  51 {
  52    ULONG count = 0;
  53    APTR card = NULL;
  54    UWORD vendor_id, product_id;
  55
  56    while((card = PCIFindBoardTagList(card, NULL)) != NULL)
  57    {
  58       vendor_id = PCIReadConfigWord(card, CYBPCICONFIG_VENDOR);
  59       product_id = PCIReadConfigWord(card, CYBPCICONFIG_DEVICE);
  60       if(IsCardCompatible(vendor_id, product_id, base))
  61          count++;
  62    }
  63
  64    return count;
  65 }
  66
  67
  68
  69 /****i* prism2.device/AllocCybPCICard **************************************
  70 *
  71 *   NAME
  72 *       AllocCybPCICard -- Create a unit.
  73 *
  74 *   SYNOPSIS
  75 *       context = AllocCybPCICard(index)
  76 *
  77 *       struct BusContext *AllocCybPCICard(ULONG);
  78 *
  79 ****************************************************************************
  80 *
  81 */
  82
  83 struct BusContext *AllocCybPCICard(ULONG index, struct DevBase *base)
  84 {
  85    BOOL success = TRUE;
  86    struct BusContext *context;
  87    APTR card = NULL;
  88    UWORD i = 0;
  89    UPINT vendor_id, product_id, plx_base;
  90    UBYTE io_range_no;
  91    volatile UBYTE *cor_reg;
  92    ULONG pci_control;
  93
  94    /* Find a compatible card */
  95
  96    context = AllocMem(sizeof(struct BusContext), MEMF_PUBLIC | MEMF_CLEAR);
  97    if(context == NULL)
  98       success = FALSE;
  99
 100    if(success)
 101    {
 102       while(i <= index)
 103       {
 104          card = PCIFindBoardTagList(card, NULL);
 105          vendor_id = PCIReadConfigWord(card, CYBPCICONFIG_VENDOR);
 106          product_id = PCIReadConfigWord(card, CYBPCICONFIG_DEVICE);
 107          if(IsCardCompatible(vendor_id, product_id, base))
 108             i++;
 109       }
 110
 111       context->card = card;
 112       if(card == NULL)
 113          success = FALSE;
 114    }
 115
 116    if(success)
 117    {
 118       /* Find out what type of Prism II PCI card this is */
 119
 120       context->bus_type = GetBusType(product_id, base);
 121
 122       if(context->bus_type == TMD_BUS)
 123       {
 124          /* Enable the PCCard */
 125
 126          cor_reg = (APTR)PCIGetBoardAttr(card, CYBPCITAG_BASEADDRESS1);
 127          BYTEOUT((UPINT)cor_reg, COR_ENABLE);
 128          io_range_no = 2;
 129       }
 130       else if(context->bus_type == PLX_BUS)
 131       {
 132          /* Enable interrupts on the bridge */
 133
 134          plx_base = PCIGetBoardAttr(card, CYBPCITAG_BASEADDRESS1);
 135          LELONGOUT(plx_base + PLX9052_INTS,
 136             LELONGIN(plx_base + PLX9052_INTS) | (1 << 6));
 137
 138          /* Enable the PCCard */
 139
 140          cor_reg = (APTR)PCIGetBoardAttr(card, CYBPCITAG_BASEADDRESS2);
 141          cor_reg += 0x3e0;
 142          *cor_reg = COR_ENABLE;
 143          io_range_no = 3;
 144       }
 145       else
 146          io_range_no = 0;
 147
 148       /* Get the I/O base of the wireless chip */
 149
 150       context->io_base = PCIGetBoardAttr(card,
 151          CYBPCITAG_BASEADDRESS0 + io_range_no);
 152       if(context->io_base == 0)
 153          success = FALSE;
 154    }
 155
 156    if(!success)
 157    {
 158       FreeCybPCICard(context, base);
 159       context = NULL;
 160    }
 161
 162    return context;
 163 }
 164
 165
 166
 167 /****i* prism2.device/FreeCybPCICard ***************************************
 168 *
 169 *   NAME
 170 *       FreeCybPCICard
 171 *
 172 *   SYNOPSIS
 173 *       FreeCybPCICard(context)
 174 *
 175 *       VOID FreeCybPCICard(struct BusContext *);
 176 *
 177 ****************************************************************************
 178 *
 179 */
 180
 181 VOID FreeCybPCICard(struct BusContext *context, struct DevBase *base)
 182 {
 183    APTR card;
 184    APTR owner;
 185
 186    if(context != NULL)
 187       FreeMem(context, sizeof(struct BusContext));
 188
 189    return;
 190 }
 191
 192
 193
 194 /****i* prism2.device/AddCybPCIIntServer ***********************************
 195 *
 196 *   NAME
 197 *       AddCybPCIIntServer
 198 *
 199 *   SYNOPSIS
 200 *       success = AddCybPCIIntServer(card, interrupt)
 201 *
 202 *       BOOL AddCybPCIIntServer(APTR, struct Interrupt *);
 203 *
 204 ****************************************************************************
 205 *
 206 */
 207
 208 BOOL AddCybPCIIntServer(APTR card, struct Interrupt *interrupt,
 209    struct DevBase *base)
 210 {
 211    return (interrupt->is_Data = PCICreateIntObjectTagList(card,
 212       (APTR)interrupt->is_Code, interrupt->is_Data, NULL)) != NULL;
 213 }
 214
 215
 216
 217 /****i* prism2.device/RemCybPCIIntServer ***********************************
 218 *
 219 *   NAME
 220 *       RemCybPCIIntServer
 221 *
 222 *   SYNOPSIS
 223 *       RemCybPCIIntServer(card, interrupt)
 224 *
 225 *       VOID RemCybPCIIntServer(APTR, struct Interrupt *);
 226 *
 227 ****************************************************************************
 228 *
 229 */
 230
 231 VOID RemCybPCIIntServer(APTR card, struct Interrupt *interrupt,
 232    struct DevBase *base)
 233 {
 234    if(interrupt->is_Data != NULL)
 235       PCIDeleteIntObject(interrupt->is_Data);
 236
 237    return;
 238 }
 239
 240
 241