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