workbench/devs/networks/etherlink3/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* etherlink3.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* etherlink3.device/AllocOpenPCICard *********************************
  69 *
  70 *   NAME
  71 *       AllocOpenPCICard -- Create a unit.
  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       if(card == NULL)
 108          success = FALSE;
 109    }
 110
 111    /* Get base address and generation */
 112
 113    if(success)
 114    {
 115       context->io_base = (UPINT)card->base_address[BAR_NO];
 116       if(context->io_base == NULL)
 117          success = FALSE;
 118       pci_write_config_word(PCI_COMMAND,
 119          PCI_COMMAND_MEMORY | PCI_COMMAND_IO, card);
 120       context->generation = GetGeneration(product_id, base);
 121
 122       /* Cards requiring DMA are not supported under MorphOS because
 123          logical and physical addresses differ */
 124
 125       if (context->generation >= BOOMERANG_GEN)
 126          success = FALSE;
 127    }
 128
 129    if(!success)
 130    {
 131       FreeOpenPCICard(context, base);
 132       context = NULL;
 133    }
 134
 135    return context;
 136 }
 137
 138
 139
 140 /****i* etherlink3.device/FreeOpenPCICard **********************************
 141 *
 142 *   NAME
 143 *       FreeOpenPCICard
 144 *
 145 *   SYNOPSIS
 146 *       FreeOpenPCICard(context)
 147 *
 148 *       VOID FreeOpenPCICard(struct BusContext *);
 149 *
 150 ****************************************************************************
 151 *
 152 */
 153
 154 VOID FreeOpenPCICard(struct BusContext *context, struct DevBase *base)
 155 {
 156    if(context != NULL)
 157       FreeMem(context, sizeof(struct BusContext));
 158
 159    return;
 160 }
 161
 162
 163
 164 /****i* etherlink3.device/AddOpenPCIIntServer ******************************
 165 *
 166 *   NAME
 167 *       AddOpenPCIIntServer
 168 *
 169 *   SYNOPSIS
 170 *       success = AddOpenPCIIntServer(card, interrupt)
 171 *
 172 *       BOOL AddOpenPCIIntServer(APTR, struct Interrupt *);
 173 *
 174 ****************************************************************************
 175 *
 176 */
 177
 178 BOOL AddOpenPCIIntServer(APTR card, struct Interrupt *interrupt,
 179    struct DevBase *base)
 180 {
 181    return pci_add_intserver(interrupt, card);
 182 }
 183
 184
 185
 186 /****i* etherlink3.device/RemOpenPCIIntServer ******************************
 187 *
 188 *   NAME
 189 *       RemOpenPCIIntServer
 190 *
 191 *   SYNOPSIS
 192 *       RemOpenPCIIntServer(card, interrupt)
 193 *
 194 *       VOID RemOpenPCIIntServer(APTR, struct Interrupt *);
 195 *
 196 ****************************************************************************
 197 *
 198 */
 199
 200 VOID RemOpenPCIIntServer(APTR card, struct Interrupt *interrupt,
 201    struct DevBase *base)
 202 {
 203    pci_rem_intserver(interrupt, card);
 204
 205    return;
 206 }
 207
 208
 209