workbench/devs/networks/prism2/openpci.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/openpci.h>
  25
  26 #include <proto/exec.h>
  27 #include <proto/openpci.h>
  28
  29 #include "pci.h"
  30 #include "plx9052.h"
  31 #include "prism2.h"
  32
  33 #include "pci_protos.h"
  34 #include "openpci_protos.h"
  35 #include "timer_protos.h"
  36
  37
  38 /****i* prism2.device/GetOpenPCICount **************************************
  39 *
  40 *   NAME
  41 *       GetOpenPCICount
  42 *
  43 *   SYNOPSIS
  44 *       count = GetOpenPCICount()
  45 *
  46 *       ULONG GetOpenPCICount();
  47 *
  48 ****************************************************************************
  49 *
  50 */
  51
  52 ULONG GetOpenPCICount(struct DevBase *base)
  53 {
  54    ULONG count = 0;
  55    struct pci_dev *card = NULL;
  56    UWORD vendor_id, product_id;
  57
  58    while((card = pci_find_device(0xffff, 0xffff, card)) != NULL)
  59    {
  60       product_id = pci_read_config_word(PCI_DEVICE_ID, card);
  61       vendor_id = pci_read_config_word(PCI_VENDOR_ID, card);
  62       if(IsCardCompatible(vendor_id, product_id, base))
  63          count++;
  64    }
  65
  66    return count;
  67 }
  68
  69
  70
  71 /****i* prism2.device/AllocOpenPCICard *************************************
  72 *
  73 *   NAME
  74 *       AllocOpenPCICard -- Create a unit.
  75 *
  76 *   SYNOPSIS
  77 *       context = AllocOpenPCICard(index)
  78 *
  79 *       struct BusContext *AllocOpenPCICard(ULONG);
  80 *
  81 ****************************************************************************
  82 *
  83 */
  84
  85 struct BusContext *AllocOpenPCICard(ULONG index, struct DevBase *base)
  86 {
  87    BOOL success = TRUE;
  88    struct BusContext *context;
  89    struct pci_dev *card = NULL;
  90    UWORD i = 0, vendor_id, product_id, io_range_no;
  91    ULONG value;
  92    UPINT io_reg, int_reg;
  93    volatile UBYTE *cor_reg;
  94
  95    /* Find a compatible card */
  96
  97    context = AllocMem(sizeof(struct BusContext), MEMF_PUBLIC | MEMF_CLEAR);
  98    if(context == NULL)
  99       success = FALSE;
 100
 101    if(success)
 102    {
 103       while(i <= index)
 104       {
 105          card = pci_find_device(0xffff, 0xffff, card);
 106          product_id = pci_read_config_word(PCI_DEVICE_ID, card);
 107          vendor_id = pci_read_config_word(PCI_VENDOR_ID, card);
 108          if(IsCardCompatible(vendor_id, product_id, base))
 109             i++;
 110       }
 111
 112       context->card = card;
 113       if(card == NULL)
 114          success = FALSE;
 115    }
 116
 117    if(success)
 118    {
 119       /* Find out what type of Prism II PCI card this is */
 120
 121       context->bus_type = GetBusType(product_id, base);
 122       pci_write_config_word(PCI_COMMAND,
 123          PCI_COMMAND_MEMORY | PCI_COMMAND_IO, card);
 124
 125       if(context->bus_type == TMD_BUS)
 126       {
 127          /* Reset and enable the PCCard */
 128
 129          io_reg = (UPINT)card->base_address[1];
 130          BYTEOUT(io_reg, COR_RESET);
 131          BusyMilliDelay(RESET_DELAY, base);
 132          BYTEOUT(io_reg, COR_ENABLE);
 133          BusyMilliDelay(RESET_DELAY, base);
 134          io_range_no = 2;
 135       }
 136       else if(context->bus_type == PLX_BUS)
 137       {
 138          /* Reset and enable the PCCard */
 139
 140          cor_reg = (volatile UBYTE *)card->base_address[2] + 0x3e0;
 141          *cor_reg = COR_ENABLE;
 142          BusyMilliDelay(RESET_DELAY, base);
 143
 144          /* Enable interrupts on the bridge */
 145
 146          int_reg = (UPINT)card->base_address[1] + PLX9052_INTS;
 147          value = LONGIN(int_reg);
 148          LONGOUT(int_reg, value | (1 << 6));
 149          if((LONGIN(int_reg) & (1 << 6)) == 0)
 150             success = FALSE;
 151          io_range_no = 3;
 152       }
 153       else
 154          io_range_no = 0;
 155
 156       /* Get the I/O base of the wireless chip */
 157
 158       context->have_card = TRUE;
 159       context->io_base = (UPINT)card->base_address[io_range_no];
 160
 161       if(context->bus_type == PCI_BUS)
 162       {
 163          /* Reset and enable the card */
 164
 165          cor_reg = (volatile UBYTE *)context->io_base + (P2_REG_PCICOR * 2);
 166          *cor_reg = COR_RESET;
 167          BusyMilliDelay(250, base);
 168          *cor_reg = 0;
 169          BusyMilliDelay(500, base);
 170       }
 171    }
 172
 173    if(!success)
 174    {
 175       FreeOpenPCICard(context, base);
 176       context = NULL;
 177    }
 178
 179    return context;
 180 }
 181
 182
 183
 184 /****i* prism2.device/FreeOpenPCICard **************************************
 185 *
 186 *   NAME
 187 *       FreeOpenPCICard
 188 *
 189 *   SYNOPSIS
 190 *       FreeOpenPCICard(context)
 191 *
 192 *       VOID FreeOpenPCICard(struct BusContext *);
 193 *
 194 ****************************************************************************
 195 *
 196 */
 197
 198 VOID FreeOpenPCICard(struct BusContext *context, struct DevBase *base)
 199 {
 200    struct pci_dev *card;
 201
 202    ULONG value;
 203    UPINT io_reg, int_reg;
 204    volatile UBYTE *cor_reg;
 205
 206    if(context != NULL)
 207    {
 208       card = context->card;
 209       if(card != NULL)
 210       {
 211          if(context->bus_type == TMD_BUS)
 212          {
 213             /* Disable the PCCard */
 214
 215             io_reg = (UPINT)card->base_address[1];
 216             BYTEOUT(io_reg, 0);
 217          }
 218          else if(context->bus_type == PLX_BUS)
 219          {
 220             /* Disable interrupts on the bridge */
 221
 222             int_reg = (UPINT)card->base_address[1] + PLX9052_INTS;
 223             value = LONGIN(int_reg);
 224             LONGOUT(int_reg, value & ~(1 << 6));
 225
 226             /* Disable the PCCard */
 227
 228             cor_reg = (volatile UBYTE *)card->base_address[2] + 0x3e0;
 229             *cor_reg = COR_RESET;
 230             BusyMilliDelay(250, base);
 231             *cor_reg = 0;
 232          }
 233
 234          FreeMem(context, sizeof(struct BusContext));
 235       }
 236    }
 237
 238    return;
 239 }
 240
 241
 242
 243 /****i* prism2.device/AddOpenPCIIntServer **********************************
 244 *
 245 *   NAME
 246 *       AddOpenPCIIntServer
 247 *
 248 *   SYNOPSIS
 249 *       success = AddOpenPCIIntServer(card, interrupt)
 250 *
 251 *       BOOL AddOpenPCIIntServer(APTR, struct Interrupt *);
 252 *
 253 ****************************************************************************
 254 *
 255 */
 256
 257 BOOL AddOpenPCIIntServer(APTR card, struct Interrupt *interrupt,
 258    struct DevBase *base)
 259 {
 260    return pci_add_intserver(interrupt, card);
 261 }
 262
 263
 264
 265 /****i* prism2.device/RemOpenPCIIntServer **********************************
 266 *
 267 *   NAME
 268 *       RemOpenPCIIntServer
 269 *
 270 *   SYNOPSIS
 271 *       RemOpenPCIIntServer(card, interrupt)
 272 *
 273 *       VOID RemOpenPCIIntServer(APTR, struct Interrupt *);
 274 *
 275 ****************************************************************************
 276 *
 277 */
 278
 279 VOID RemOpenPCIIntServer(APTR card, struct Interrupt *interrupt,
 280    struct DevBase *base)
 281 {
 282    pci_rem_intserver(interrupt, card);
 283
 284    return;
 285 }
 286
 287
 288