workbench/devs/networks/atheros5000/openpci.c

   1 /*
   2
   3 Copyright (C) 2004-2011 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
  31 #include "pci_protos.h"
  32 #include "openpci_protos.h"
  33
  34
  35 /****i* atheros5000.device/GetOpenPCICount *********************************
  36 *
  37 *   NAME
  38 *       GetOpenPCICount
  39 *
  40 *   SYNOPSIS
  41 *       count = GetOpenPCICount()
  42 *
  43 *       ULONG GetOpenPCICount();
  44 *
  45 ****************************************************************************
  46 *
  47 */
  48
  49 ULONG GetOpenPCICount(struct DevBase *base)
  50 {
  51    ULONG count = 0;
  52    struct pci_dev *card = NULL;
  53    UWORD vendor_id, product_id;
  54
  55    while((card = pci_find_device(0xffff, 0xffff, card)) != NULL)
  56    {
  57       product_id = pci_read_config_word(PCI_DEVICE_ID, card);
  58       vendor_id = pci_read_config_word(PCI_VENDOR_ID, card);
  59       if(IsCardCompatible(vendor_id, product_id, base))
  60          count++;
  61    }
  62
  63    return count;
  64 }
  65
  66
  67
  68 /****i* atheros5000.device/AllocOpenPCICard ********************************
  69 *
  70 *   NAME
  71 *       AllocOpenPCICard -- Take control of a card.
  72 *
  73 *   SYNOPSIS
  74 *       context = AllocOpenPCICard(index)
  75 *
  76 *       struct BusContext *AllocOpenPCICard(ULONG);
  77 *
  78 ****************************************************************************
  79 *
  80 */
  81
  82 struct BusContext *AllocOpenPCICard(ULONG index, struct DevBase *base)
  83 {
  84    BOOL success = TRUE;
  85    struct BusContext *context;
  86    struct pci_dev *card = 0;
  87    UWORD i = 0, vendor_id, product_id;
  88
  89    /* Find a compatible card */
  90
  91    context = AllocMem(sizeof(struct BusContext), MEMF_PUBLIC | MEMF_CLEAR);
  92    if(context == NULL)
  93       success = FALSE;
  94
  95    if(success)
  96    {
  97       while(i <= index)
  98       {
  99          card = pci_find_device(0xffff, 0xffff, card);
 100          product_id = pci_read_config_word(PCI_DEVICE_ID, card);
 101          vendor_id = pci_read_config_word(PCI_VENDOR_ID, card);
 102          if(IsCardCompatible(vendor_id, product_id, base))
 103             i++;
 104       }
 105
 106       context->card = card;
 107       context->id = product_id;
 108    }
 109
 110    /* Get base address */
 111
 112    if(success)
 113    {
 114       context->io_base = (UPINT)card->base_address[BAR_NO];
 115       if(context->io_base == NULL)
 116          success = FALSE;
 117
 118       /* Only enable card once, otherwise it may stop working */
 119
 120       if((pci_read_config_word(PCI_COMMAND, card)
 121          & (PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER)) == 0)
 122          pci_write_config_word(PCI_COMMAND,
 123             PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER, card);
 124    }
 125
 126    if(!success)
 127    {
 128       FreeOpenPCICard(context, base);
 129       context = NULL;
 130    }
 131
 132    return context;
 133 }
 134
 135
 136
 137 /****i* atheros5000.device/FreeOpenPCICard *********************************
 138 *
 139 *   NAME
 140 *       FreeOpenPCICard -- Release a card.
 141 *
 142 *   SYNOPSIS
 143 *       FreeOpenPCICard(context)
 144 *
 145 *       VOID FreeOpenPCICard(struct BusContext *);
 146 *
 147 ****************************************************************************
 148 *
 149 */
 150
 151 VOID FreeOpenPCICard(struct BusContext *context, struct DevBase *base)
 152 {
 153    if(context != NULL)
 154       FreeMem(context, sizeof(struct BusContext));
 155
 156    return;
 157 }
 158
 159
 160
 161 /****i* atheros5000.device/AddOpenPCIIntServer *****************************
 162 *
 163 *   NAME
 164 *       AddOpenPCIIntServer
 165 *
 166 *   SYNOPSIS
 167 *       success = AddOpenPCIIntServer(card, interrupt)
 168 *
 169 *       BOOL AddOpenPCIIntServer(APTR, struct Interrupt *);
 170 *
 171 ****************************************************************************
 172 *
 173 */
 174
 175 BOOL AddOpenPCIIntServer(APTR card, struct Interrupt *interrupt,
 176    struct DevBase *base)
 177 {
 178    return pci_add_intserver(interrupt, card);
 179 }
 180
 181
 182
 183 /****i* atheros5000.device/RemOpenPCIIntServer *****************************
 184 *
 185 *   NAME
 186 *       RemOpenPCIIntServer
 187 *
 188 *   SYNOPSIS
 189 *       RemOpenPCIIntServer(card, interrupt)
 190 *
 191 *       VOID RemOpenPCIIntServer(APTR, struct Interrupt *);
 192 *
 193 ****************************************************************************
 194 *
 195 */
 196
 197 VOID RemOpenPCIIntServer(APTR card, struct Interrupt *interrupt,
 198    struct DevBase *base)
 199 {
 200    pci_rem_intserver(interrupt, card);
 201
 202    return;
 203 }
 204
 205