workbench/devs/networks/intelpro100/openpci.c

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