root/dev/pci/if_sandrv.c

DEFINITIONS

1. sdla_hw_probe_t
2. sdlahw_card_t
3. sdlahw_t
4. san_match
5. san_attach
6. sdladrv_init
7. sdladrv_exit
8. sdla_save_hw_probe
9. sdla_aft_hw_select
10. sdla_pci_probe
11. sdla_intr_establish
12. sdla_intr_disestablish
13. sdla_get_hw_devices
14. sdla_get_hw_adptr_cnt
15. sdla_card_register
16. sdla_card_unregister
17. sdla_card_search
18. sdla_hw_register
19. sdla_hw_unregister
20. sdla_hw_search
21. sdla_setup
22. sdla_down
23. sdla_read_int_stat
24. sdla_cmd
25. sdla_exec
26. sdla_peek
27. sdla_peek_by_4
28. sdla_poke
29. sdla_poke_by_4
30. sdla_poke_byte
31. sdla_set_bit
32. sdla_clear_bit
33. sdla_detect_aft
34. sdla_detect
35. sdla_is_te1
36. sdla_check_mismatch
37. sdla_getcfg
38. sdla_get_hwcard
39. sdla_get_hwprobe
40. sdla_bus_write_1
41. sdla_bus_write_2
42. sdla_bus_write_4
43. sdla_bus_read_1
44. sdla_bus_read_2
45. sdla_bus_read_4
46. sdla_pci_read_config_dword
47. sdla_pci_read_config_word
48. sdla_pci_read_config_byte
49. sdla_pci_write_config_dword
50. sdla_pci_write_config_word

    1 /*      $OpenBSD: if_sandrv.c,v 1.11 2006/04/20 20:31:12 miod Exp $     */
    3 /*-
    4  * Copyright (c) 2001-2004 Sangoma Technologies (SAN)
    5  * All rights reserved.  www.sangoma.com
    6  *
    7  * This code is written by Alex Feldman <al.feldman@sangoma.com> for SAN.
    8  *
    9  * Redistribution and use in source and binary forms, with or without
   10  * modification, are permitted provided that the following conditions
   11  * are met:
   12  * 1. Redistributions of source code must retain the above copyright
   13  *    notice, this list of conditions and the following disclaimer.
   14  * 2. Redistributions in binary form must reproduce the above
   15  *    copyright notice, this list of conditions and the following disclaimer
   16  *    in the documentation and/or other materials provided with the
   17  *    distribution.
   18  * 3. Neither the name of Sangoma Technologies nor the names of its
   19  *    contributors may be used to endorse or promote products derived
   20  *    from this software without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY SANGOMA TECHNOLOGIES AND CONTRIBUTORS
   23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   25  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   26  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
   32  * THE POSSIBILITY OF SUCH DAMAGE.
   33  */
   35 #define __SDLA_HW_LEVEL
   36 #define __SDLADRV__
   38 #include <sys/types.h>
   39 #include <sys/param.h>
   40 #include <sys/systm.h>
   41 #include <sys/syslog.h>
   42 #include <sys/malloc.h>
   43 #include <sys/kernel.h>
   45 #include <dev/pci/pcireg.h>
   46 #include <dev/pci/pcivar.h>
   47 #include <dev/pci/if_san_front_end.h>
   48 #include <dev/pci/if_sandrv.h>
   50 #define EXEC_DELAY      20      /* shared memory access delay, mks */
   51 #define EXEC_TIMEOUT    (hz*2)
   52 #define MAX_NLOOPS      (EXEC_DELAY*2000)
   53                         /* timeout used if jiffies are stopped
   54                         ** EXEC_DELAY=20
   55                         ** EXEC_TIMEOUT=EXEC_DELAY*2000 = 40000
   56                         ** 40000 ~= 80 jiffies = EXEC_TIMEOUT */
   58 #define EXEC_HZ_DIVISOR 8/10
   59                         /* We don't want to wait a full second on sdla_exec
   60                         ** timeout, thus use HZ * EXEC_HZ_DIVISOR to get
   61                         ** the number of jiffies we would like to wait */
   63 #define IS_SUPPORTED_ADAPTER(hw)        ((hw)->type == SDLA_AFT)
   65 #define SDLA_CTYPE_NAME(type)                   \
   66         ((type) == SDLA_AFT) ? "AFT" : "Unknown"
   68 #define IS_AFT(hw)      (hw->type == SDLA_AFT)
   70 /* Definitions for identifying and finding S514 PCI adapters */
   71 #define V3_VENDOR_ID            0x11B0          /* V3 vendor ID number */
   72 #define V3_DEVICE_ID            0x0002          /* V3 device ID number */
   73 #define SANGOMA_SUBSYS_VENDOR   0x4753          /* ID for Sangoma */
   75 /* Definition for identifying and finding XILINX PCI adapters */
   76 #define SANGOMA_PCI_VENDOR      0x1923          /* Old value -> 0x11B0 */
   77 #define SANGOMA_PCI_VENDOR_OLD  0x10EE          /* Old value -> 0x11B0 */
   78 #define SANGOMA_PCI_DEVICE      0x0300          /* Old value -> 0x0200 */
   80 #define A101_1TE1_SUBSYS_VENDOR 0xA010  /* A101 with T1/E1 1 line  */
   81 #define A101_2TE1_SUBSYS_VENDOR 0xA011  /* A101 with T1/E1 2 lines */
   82 #define A105_T3_SUBSYS_VENDOR   0xA020  /* A102 with T3 */
   84 /* Read PCI SUBVENDOR ID */
   85 #define PCI_SUBVENDOR_MASK      0xFFFF
   86 #define PCI_SUBVENDOR(pa)       (pci_conf_read(pa->pa_pc, pa->pa_tag,   \
PCI_SUBSYS_ID_REG) & PCI_SUBVENDOR_MASK)
   88 #define PCI_DEVICE_MASK         0xFFFF0000
   89 #define PCI_DEVICE(id)          ((id & PCI_DEVICE_MASK ) >> 16)
   91 /* Status values */
   92 #define SDLA_MEM_RESERVED       0x0001
   93 #define SDLA_MEM_MAPPED         0x0002
   94 #define SDLA_IO_MAPPED          0x0004
   95 #define SDLA_PCI_ENABLE         0x0008
   97 struct san_softc {
   98         struct device           dev;
   99         struct pci_attach_args  pa;
  100 };
  102 typedef struct sdla_hw_probe {
  103         int                             used;
  104         unsigned char                   hw_info[100];
LIST_ENTRY(sdla_hw_probe)       next;
  106 } sdla_hw_probe_t;
  108 /*
  109  * This structure keeps common parameters per physical card.
  110  */
  111 typedef struct sdlahw_card {
  112         int                     used;
  113         unsigned int            type;           /* S50x/S514/ADSL/XILINX */
  114         unsigned int            atype;          /* SubVendor ID */
  115         unsigned char           core_id;        /* SubSystem ID [0..7] */
  116         unsigned char           core_rev;       /* SubSystem ID [8..15] */
  117         unsigned char           pci_extra_ver;
  118         unsigned int            slot_no;
  119         unsigned int            bus_no;
bus_space_tag_t         memt;
  121         struct pci_attach_args  pa;     /* PCI config header info */
pci_intr_handle_t       ih;
LIST_ENTRY(sdlahw_card) next;
  124 } sdlahw_card_t;
  126 /*
  127  * Adapter hardware configuration. Pointer to this structure is passed to all
  128  * APIs.
  129  */
  130 typedef struct sdlahw {
  131         int                      used;
  132         unsigned                 magic;
  133         char                     devname[20];
u_int16_t                status;
  135         int                      irq;           /* interrupt request level */
  136         unsigned int             cpu_no;        /* PCI CPU Number */
  137         char                     auto_pci_cfg;  /* Auto PCI configuration */
bus_addr_t               mem_base_addr;
bus_space_handle_t       dpmbase;       /* dual-port memory base */
  140         unsigned                 dpmsize;       /* dual-port memory size */
  141         unsigned long            memory;        /* memory size */
  143         unsigned                 reserved[5];
  144         unsigned char            hw_info[100];
u_int16_t                configured;
  147         void                    *arg;           /* card structure */
sdla_hw_probe_t         *hwprobe;
sdlahw_card_t           *hwcard;
LIST_ENTRY(sdlahw)       next;
  151 } sdlahw_t;
  153 /* Entry Point for Low-Level function */
  154 int sdladrv_init(void);
  155 int sdladrv_exit(void);
  157 static int sdla_pci_probe(int, struct pci_attach_args *);
  159 /* PCI bus interface function */
  160 static int sdla_pci_write_config_word(void *, int, u_int16_t);
  161 static int sdla_pci_write_config_dword(void *, int, u_int32_t);
  162 static int sdla_pci_read_config_byte(void *, int, u_int8_t *);
  163 static int sdla_pci_read_config_word(void *, int, u_int16_t *);
  164 static int sdla_pci_read_config_dword(void *, int, u_int32_t *);
  166 static int sdla_detect  (sdlahw_t *);
  167 static int sdla_detect_aft(sdlahw_t *);
  168 static int sdla_exec(sdlahw_t *, unsigned long);
  169 static void sdla_peek_by_4(sdlahw_t *, unsigned long, void *, unsigned int);
  170 static void sdla_poke_by_4(sdlahw_t *, unsigned long, void *, unsigned int);
  172 static sdlahw_card_t* sdla_card_register(u_int16_t, int, int);
  173 #if 0
  174 static int sdla_card_unregister (unsigned char, int, int, int);
  175 #endif
  176 static sdlahw_card_t* sdla_card_search(u_int16_t, int, int);
  178 static sdlahw_t* sdla_hw_register(sdlahw_card_t *, int, int, void *);
  179 #if 0
  180 static int sdla_hw_unregister(sdlahw_card_t*, int);
  181 #endif
  182 static sdlahw_t* sdla_hw_search(u_int16_t, int, int, int);
  184 static sdlahw_t* sdla_aft_hw_select (sdlahw_card_t *, int, int,
  185     struct pci_attach_args *);
  186 static void sdla_save_hw_probe (sdlahw_t*, int);
  188 /* SDLA PCI device relative entry point */
  189 int     san_match(struct device *, void *, void *);
  190 void    san_attach(struct device *, struct device *, void *);
  193 struct cfdriver san_cd = {
NULL, "san", DV_IFNET
  195 };
  197 struct cfattach san_ca = {
  198         sizeof(struct san_softc), san_match, san_attach
  199 };
  201 extern int ticks;
  203 /* SDLA ISA/PCI varibles */
  204 static int       Sangoma_cards_no = 0;
  205 static int       Sangoma_devices_no = 0;
  206 static int       Sangoma_PCI_cards_no = 0;
  208 /* private data */
  209 char            *san_drvname = "san";
  211 /* Array of already initialized PCI slots */
  212 static int pci_slot_ar[MAX_S514_CARDS];
LIST_HEAD(, sdlahw_card) sdlahw_card_head =
LIST_HEAD_INITIALIZER(sdlahw_card_head);
LIST_HEAD(, sdlahw) sdlahw_head =
LIST_HEAD_INITIALIZER(sdlahw_head);
LIST_HEAD(, sdla_hw_probe) sdlahw_probe_head =
LIST_HEAD_INITIALIZER(sdlahw_probe_head);
  220 static sdla_hw_type_cnt_t sdla_adapter_cnt;
  224 /*
  225  * PCI Device Driver Entry Points
  226  */
  227 int
san_match(struct device *parent, void *match, void *aux)
  229 {
  230         struct pci_attach_args* pa = aux;
u_int16_t               vendor_id = PCI_VENDOR(pa->pa_id);
u_int16_t               device_id = PCI_DEVICE(pa->pa_id);
  234         if ((vendor_id == SANGOMA_PCI_VENDOR ||
vendor_id == SANGOMA_PCI_VENDOR_OLD) &&
device_id == SANGOMA_PCI_DEVICE) {
  237                 return (1);
  238         }
  239         return (0);
  240 }
  242 #define PCI_CBIO        0x10
  243 void
san_attach(struct device *parent, struct device *self, void *aux)
  245 {
  246         struct pci_attach_args*         pa = aux;
u_int16_t                       vendor_id = PCI_VENDOR(pa->pa_id);
u_int16_t                       subvendor_id = PCI_SUBVENDOR(pa);
  249         int                             atype = 0x00;
atype = PCI_PRODUCT(pci_conf_read(pa->pa_pc, pa->pa_tag,
PCI_SUBSYS_ID_REG));
  253         switch (vendor_id) {
  254         case SANGOMA_PCI_VENDOR_OLD:
  255         case SANGOMA_PCI_VENDOR:
  256                 switch (subvendor_id) {
  257                 case A101_1TE1_SUBSYS_VENDOR:
atype   = A101_ADPTR_1TE1;
  259                         break;
  260                 case A101_2TE1_SUBSYS_VENDOR:
atype   = A101_ADPTR_2TE1;
  262                         break;
  263                 default:
  264                         return;
  265                 }
  266                 break;
  267         default:
  268                 return;
  269         }
  271         if (sdla_pci_probe(atype, pa)) {
printf(": PCI probe FAILED!\n");
  273                 return;
  274         }
  276 #ifdef DEBUG
  277         switch (PCI_VENDOR(pa->pa_id)) {
  278         case V3_VENDOR_ID:
  279                 switch (atype) {
  280                 case S5141_ADPTR_1_CPU_SERIAL:
log(LOG_INFO, "%s: Sangoma S5141/FT1 (Single CPU) "
  282                             "adapter\n", self->dv_xname);
  283                         break;
  284                 case S5142_ADPTR_2_CPU_SERIAL:
log(LOG_INFO, "%s: Sangoma S5142 (Dual CPU) adapter\n",
self->dv_xname);
  287                         break;
  288                 case S5143_ADPTR_1_CPU_FT1:
log(LOG_INFO, "%s: Sangoma S5143 (Single CPU) "
  290                             "FT1 adapter\n", self->dv_xname);
  291                         break;
  292                 case S5144_ADPTR_1_CPU_T1E1:
  293                 case S5148_ADPTR_1_CPU_T1E1:
log(LOG_INFO, "%s: Sangoma S5144 (Single CPU) "
  295                             "T1/E1 adapter\n", self->dv_xname);
  296                         break;
  297                 case S5145_ADPTR_1_CPU_56K:
log(LOG_INFO, "%s: Sangoma S5145 (Single CPU) "
  299                             "56K adapter\n", self->dv_xname);
  300                         break;
  301                 case S5147_ADPTR_2_CPU_T1E1:
log(LOG_INFO, "%s: Sangoma S5147 (Dual CPU) "
  303                             "T1/E1 adapter\n", self->dv_xname);
  304                         break;
  305                 }
  306                 break;
  308         case SANGOMA_PCI_VENDOR_OLD:
  309                 switch (atype) {
  310                 case A101_ADPTR_1TE1:
log(LOG_INFO, "%s: Sangoma AFT (1 channel) "
  312                             "T1/E1 adapter\n", self->dv_xname);
  313                         break;
  314                 case A101_ADPTR_2TE1:
log(LOG_INFO, "%s: Sangoma AFT (2 channels) "
  316                             "T1/E1 adapter\n", self->dv_xname);
  317                         break;
  318                 }
  319                 break;
  320         }
  321 #endif
  322         return;
  323 }
  325 /*
  326  * Module init point.
  327  */
  328 int
sdladrv_init(void)
  330 {
  331         int volatile i = 0;
  333         /* Initialize the PCI Card array, which
  334          * will store flags, used to mark
  335          * card initialization state */
  336         for (i=0; i<MAX_S514_CARDS; i++)
pci_slot_ar[i] = 0xFF;
bzero(&sdla_adapter_cnt, sizeof(sdla_hw_type_cnt_t));
  341         return (0);
  342 }
  344 /*
  345  * Module deinit point.
  346  * o release all remaining system resources
  347  */
  348 int
sdladrv_exit(void)
  350 {
  351 #if 0
sdla_hw_probe_t *elm_hw_probe;
sdlahw_t        *elm_hw;
sdlahw_card_t   *elm_hw_card;
elm_hw = LIST_FIRST(&sdlahw_head);
  358         while (elm_hw) {
sdlahw_t        *tmp = elm_hw;
elm_hw = LIST_NEXT(elm_hw, next);
  361                 if (sdla_hw_unregister(tmp->hwcard, tmp->cpu_no) == EBUSY)
  362                         return EBUSY;
  363         }
LIST_INIT(&sdlahw_head);
elm_hw_card = LIST_FIRST(&sdlahw_card_head);
  367         while (elm_hw_card) {
sdlahw_card_t   *tmp = elm_hw_card;
elm_hw_card = LIST_NEXT(elm_hw_card, next);
  370                 if (sdla_card_unregister(tmp->hw_type,
tmp->slot_no,
tmp->bus_no,
tmp->ioport) == EBUSY)
  374                         return EBUSY;
  375         }
LIST_INIT(&sdlahw_card_head);
elm_hw_probe = LIST_FIRST(&sdlahw_probe_head);
  379         while (elm_hw_probe) {
sdla_hw_probe_t *tmp = elm_hw_probe;
elm_hw_probe = LIST_NEXT(elm_hw_probe, next);
  382                 if (tmp->used){
log(LOG_INFO, "HW probe info is in used (%s)\n",
elm_hw_probe->hw_info);
  385                         return EBUSY;
  386                 }
LIST_REMOVE(tmp, next);
free(tmp, M_DEVBUF);
  389         }
  390 #endif
  391         return (0);
  392 }
  394 static void
sdla_save_hw_probe(sdlahw_t *hw, int port)
  396 {
sdla_hw_probe_t *tmp_hw_probe;
tmp_hw_probe = malloc(sizeof(sdla_hw_probe_t), M_DEVBUF, M_NOWAIT);
  400         if (tmp_hw_probe == NULL)
  401                 return;
bzero(tmp_hw_probe, sizeof(sdla_hw_probe_t));
snprintf(tmp_hw_probe->hw_info, sizeof(tmp_hw_probe->hw_info),
  406                 "%s : SLOT=%d : BUS=%d : IRQ=%d : CPU=%c : PORT=%s",
SDLA_ADPTR_DECODE(hw->hwcard->atype), hw->hwcard->slot_no,
hw->hwcard->bus_no, hw->irq, SDLA_GET_CPU(hw->cpu_no), "PRI");
hw->hwprobe = tmp_hw_probe;
tmp_hw_probe->used++;
LIST_INSERT_HEAD(&sdlahw_probe_head, tmp_hw_probe, next);
  413 }
  415 static sdlahw_t*
sdla_aft_hw_select(sdlahw_card_t *hwcard, int cpu_no,
  417     int irq, struct pci_attach_args *pa)
  418 {
sdlahw_t*       hw = NULL;
  420         int             number_of_cards = 0;
hwcard->type = SDLA_AFT;
  423         switch (hwcard->atype) {
  424         case A101_ADPTR_1TE1:
hw = sdla_hw_register(hwcard, cpu_no, irq, pa);
sdla_save_hw_probe(hw, 0);
number_of_cards += 1;
  428 #ifdef DEBUG
log(LOG_INFO, "%s: %s T1/E1 card found (%s rev.%d), "
  430                     "cpu(s) 1, bus #%d, slot #%d, irq #%d\n", san_drvname,
SDLA_ADPTR_DECODE(hwcard->atype),
AFT_CORE_ID_DECODE(hwcard->core_id), hwcard->core_rev,
hwcard->bus_no, hwcard->slot_no, irq);
  434 #endif /* DEBUG */
  435                 break;
  436         case A101_ADPTR_2TE1:
hw = sdla_hw_register(hwcard, cpu_no, irq, pa);
sdla_save_hw_probe(hw, 0);
number_of_cards += 1;
  440 #ifdef DEBUG
log(LOG_INFO, "%s: %s T1/E1 card found (%s rev.%d), "
  442                     "cpu(s) 2, bus #%d, slot #%d, irq #%d\n", san_drvname,
SDLA_ADPTR_DECODE(hwcard->atype),
AFT_CORE_ID_DECODE(hwcard->core_id), hwcard->core_rev,
hwcard->bus_no, hwcard->slot_no, irq);
  446 #endif /* DEBUG */
  447                 break;
  448         case A105_ADPTR_1_CHN_T3E3:
hw = sdla_hw_register(hwcard, cpu_no, irq, pa);
sdla_save_hw_probe(hw, 0);
number_of_cards += 1;
  453 #ifdef DEBUG
log(LOG_INFO, "%s: %s T3/E3 card found, cpu(s) 1,"
  455                      "bus #%d, slot #%d, irq #%d\n", san_drvname,
SDLA_ADPTR_DECODE(hwcard->atype),
hwcard->bus_no, hwcard->slot_no, irq);
  458 #endif /* DEBUG */
  459                 break;
  460         default:
log(LOG_INFO, "%s: Unknown adapter %04X "
  462                     "(bus #%d, slot #%d, irq #%d)!\n", san_drvname,
hwcard->atype, hwcard->bus_no, hwcard->slot_no, irq);
  464                 break;
  465         }
  467         return (hw);
  468 }
  471 static int
sdla_pci_probe(int atype, struct pci_attach_args *pa)
  473 {
sdlahw_card_t*  hwcard;
sdlahw_t*       hw;
  476         /*sdladev_t*    dev = NULL;*/
  477         int dual_cpu = 0;
  478         int bus, slot, cpu = SDLA_CPU_A;
u_int16_t vendor_id, subvendor_id, device_id;
u_int8_t irq;
pci_intr_handle_t       ih;
  482         const char*                     intrstr = NULL;
bus = pa->pa_bus;
slot = pa->pa_device;
vendor_id = PCI_VENDOR(pa->pa_id);
subvendor_id = PCI_SUBVENDOR(pa);
device_id = PCI_DEVICE(pa->pa_id);
irq = (u_int8_t)pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_INTLINE);
  491         /* Map and establish the interrupt */
  492         if (pci_intr_map(pa, &ih)) {
printf(": couldn't map interrupt\n");
  494                 return (EINVAL);
  495         }
intrstr = pci_intr_string(pa->pa_pc, ih);
  497         if (intrstr != NULL)
printf(" %s\n", intrstr);
Sangoma_cards_no ++;
reg_new_card:
Sangoma_PCI_cards_no ++;
hwcard = sdla_card_register(atype, slot, bus);
  504         if (hwcard == NULL)
  505                 return (EINVAL);
hwcard->memt    = pa->pa_memt;
hwcard->ih      = ih;
hwcard->pa      = *pa;
  510         /* Increment number of available Sangoma devices */
Sangoma_devices_no ++;
  512         switch (atype) {
  513         case A101_ADPTR_1TE1:
  514         case A101_ADPTR_2TE1:
hw = sdla_aft_hw_select(hwcard, cpu, irq, pa);
sdla_adapter_cnt.AFT_adapters++;
  517                 if (atype == A101_ADPTR_2TE1)
dual_cpu = 1;
  519                 break;
  521         }
  523         if (hw == NULL)
  524             return (EINVAL);
  525         if (san_dev_attach(hw, hw->devname, sizeof(hw->devname)))
  526                 return (EINVAL);
hw->used++;
  530         if (dual_cpu && cpu == SDLA_CPU_A) {
cpu = SDLA_CPU_B;
  532                 goto reg_new_card;
  533         }
  535         return (0);
  536 }
  538 int
sdla_intr_establish(void *phw, int (*intr_func)(void*), void* intr_arg)
  540 {
sdlahw_t        *hw = (sdlahw_t*)phw;
sdlahw_card_t   *hwcard;
WAN_ASSERT(hw == NULL);
hwcard = hw->hwcard;
  546         if (pci_intr_establish(hwcard->pa.pa_pc, hwcard->ih, IPL_NET,
intr_func, intr_arg, "san") == NULL)
  548                 return (EINVAL);
  550         return 0;
  551 }
  553 int
sdla_intr_disestablish(void *phw)
  555 {
sdlahw_t        *hw = (sdlahw_t*)phw;
log(LOG_INFO, "%s: Disestablish interrupt is not defined!\n",
hw->devname);
  560         return (EINVAL);
  561 }
  563 int
sdla_get_hw_devices(void)
  565 {
  566         return (Sangoma_devices_no);
  567 }
  569 void*
sdla_get_hw_adptr_cnt(void)
  571 {
  572         return (&sdla_adapter_cnt);
  573 }
  575 static sdlahw_card_t*
sdla_card_register(u_int16_t atype, int slot_no, int bus_no)
  577 {
sdlahw_card_t   *new_hwcard, *last_hwcard;
new_hwcard = sdla_card_search(atype, slot_no, bus_no);
  581         if (new_hwcard)
  582                 return (new_hwcard);
new_hwcard = malloc(sizeof(sdlahw_card_t), M_DEVBUF, M_NOWAIT);
  585         if (!new_hwcard)
  586                 return (NULL);
bzero(new_hwcard, sizeof(sdlahw_card_t));
new_hwcard->atype       = atype;
new_hwcard->slot_no     = slot_no;
new_hwcard->bus_no      = bus_no;
  594         if (LIST_EMPTY(&sdlahw_card_head)) {
  595                 /* Initialize SAN HW parameters */
sdladrv_init();
  597         }
LIST_FOREACH(last_hwcard, &sdlahw_card_head, next) {
  599                 if (!LIST_NEXT(last_hwcard, next))
  600                         break;
  601         }
  603         if (last_hwcard)
LIST_INSERT_AFTER(last_hwcard, new_hwcard, next);
  605         else
LIST_INSERT_HEAD(&sdlahw_card_head, new_hwcard, next);
  608         return (new_hwcard);
  609 }
  611 #if 0
  612 static int
sdla_card_unregister(u_int16_t atype, int slot_no, int bus_no, int ioport)
  614 {
sdlahw_card_t*  tmp_card;
LIST_FOREACH(tmp_card, &sdlahw_card_head, next){
  618                 if (tmp_card->atype != atype){
  619                         continue;
  620                 }
  621                 if (tmp_card->slot_no == slot_no &&
tmp_card->bus_no == bus_no){
  623                         break;
  624                 }
  625         }
  626         if (tmp_card == NULL){
log(LOG_INFO,
  628                 "Error: Card didn't find %04X card (slot=%d, bus=%d)\n"
atype, slot_no, bus_no);
  630                 return (EFAULT)
  631         }
  632         if (tmp_card->used){
log(LOG_INFO,
  634                 "Error: Card is still in used (slot=%d,bus=%d,used=%d)\n",
slot_no, bus_no, tmp_card->used);
  636                 return (EBUSY);
  637         }
LIST_REMOVE(tmp_card, next);
free(tmp_card, M_DEVBUF);
  640         return 0;
  641 }
  642 #endif
  644 static sdlahw_card_t*
sdla_card_search(u_int16_t atype, int slot_no, int bus_no)
  646 {
sdlahw_card_t*  tmp_card;
LIST_FOREACH(tmp_card, &sdlahw_card_head, next) {
  650                 if (tmp_card->atype != atype)
  651                         continue;
  653                 if (tmp_card->slot_no == slot_no &&
tmp_card->bus_no == bus_no)
  655                         return (tmp_card);
  656         }
  657         return (NULL);
  658 }
  660 static sdlahw_t*
sdla_hw_register(sdlahw_card_t *card, int cpu_no, int irq, void *dev)
  662 {
sdlahw_t        *new_hw, *last_hw;
new_hw = sdla_hw_search(card->atype, card->slot_no,
card->bus_no, cpu_no);
  667         if (new_hw)
  668                 return (new_hw);
new_hw = malloc(sizeof(sdlahw_t), M_DEVBUF, M_NOWAIT);
  671         if (!new_hw)
  672                 return (NULL);
bzero(new_hw, sizeof(sdlahw_t));
new_hw->cpu_no  = cpu_no;
new_hw->irq     = irq;
new_hw->hwcard  = card;
  679 #if 0
new_hw->dev     = dev;
  681 #endif
new_hw->magic   = SDLAHW_MAGIC;
card->used++;
LIST_FOREACH(last_hw, &sdlahw_head, next) {
  686                 if (!LIST_NEXT(last_hw, next))
  687                         break;
  688         }
  689         if (last_hw)
LIST_INSERT_AFTER(last_hw, new_hw, next);
  691         else
LIST_INSERT_HEAD(&sdlahw_head, new_hw, next);
  694         return (new_hw);
  695 }
  697 #if 0
  698 static int
sdla_hw_unregister(sdlahw_card_t* hwcard, int cpu_no)
  700 {
sdlahw_t*       tmp_hw;
  702         int             i;
LIST_FOREACH(tmp_hw, &sdlahw_head, next) {
  705                 if (tmp_hw->hwcard != hwcard)
  706                         continue;
  708                 if (tmp_hw->cpu_no == cpu_no)
  709                         break;
  710         }
  712         if (tmp_hw == NULL) {
log(LOG_INFO,
  714                 "Error: Failed to find device (slot=%d,bus=%d,cpu=%c)\n",
hwcard->slot_no, hwcard->bus_no, SDLA_GET_CPU(cpu_no));
  716                 return (EFAULT);
  717         }
  718         if (tmp_hw->used) {
log(LOG_INFO,
  720                 "Error: Device is still in used (slot=%d,bus=%d,cpu=%c,%d)\n",
hwcard->slot_no,
hwcard->bus_no,
SDLA_GET_CPU(cpu_no),
hwcard->used);
  725                 return (EBUSY);
  726         }
tmp_hw->hwprobe = NULL;
tmp_hw->hwcard = NULL;
hwcard->used--;                 /* Decrement card usage */
LIST_REMOVE(tmp_hw, next);
free(tmp_hw, M_DEVBUF);
  734         return (0);
  735 }
  736 #endif
  738 static sdlahw_t*
sdla_hw_search(u_int16_t atype, int slot_no, int bus_no, int cpu_no)
  740 {
sdlahw_t*       tmp_hw;
LIST_FOREACH(tmp_hw, &sdlahw_head, next) {
  745                 if (tmp_hw->hwcard == NULL) {
log(LOG_INFO,
  747                         "Critical Error: sdla_cpu_search: line %d\n",
__LINE__);
  749                         // XXX REMOVE in LIST_FOREACH
LIST_REMOVE(tmp_hw, next);
  751                         continue;
  752                 }
  753                 if (tmp_hw->hwcard->atype != atype) {
  754                         // XXX why ???
LIST_REMOVE(tmp_hw, next);
  756                         continue;
  757                 }
  758                 if (tmp_hw->hwcard->slot_no == slot_no &&
tmp_hw->hwcard->bus_no == bus_no &&
tmp_hw->cpu_no == cpu_no)
  761                         return (tmp_hw);
  762         }
  764         return (NULL);
  765 }
  768 /*
  769  * Set up adapter.
  770  * o detect adapter type
  771  * o set up adapter shared memory
  772  * Return:      0       ok.
  773  *              < 0     error
  774  */
  776 int
sdla_setup(void *phw)
  778 {
sdlahw_card_t*  hwcard = NULL;
sdlahw_t*       hw = (sdlahw_t*)phw;
  781         int             err=0;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
hwcard = hw->hwcard;
  787         switch (hwcard->type) {
  788         case SDLA_AFT:
  789                 break;
  791         default:
log(LOG_INFO, "%s: Invalid card type %x\n",
hw->devname, hw->hwcard->type);
  794                 return (EINVAL);
  795         }
hw->dpmsize = SDLA_WINDOWSIZE;
err = sdla_detect(hw);
  800         return (err);
  801 }
  804 /*
  805  * Shut down SDLA: disable shared memory access and interrupts, stop CPU, etc.
  806  */
  807 int
sdla_down(void *phw)
  809 {
sdlahw_card_t*  card = NULL;
sdlahw_t*       hw = (sdlahw_t*)phw;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
card = hw->hwcard;
  817         switch (card->type) {
  818         case SDLA_AFT:
  819                 /* free up the allocated virtual memory */
  820                 if (hw->status & SDLA_MEM_MAPPED) {
bus_space_unmap(hw->hwcard->memt,
hw->dpmbase,
XILINX_PCI_MEM_SIZE);
hw->status &= ~SDLA_MEM_MAPPED;
  825                 }
  826                 break;
  828         default:
  829                 return (EINVAL);
  830         }
  831         return (0);
  832 }
  834 /*
  835  * Read the hardware interrupt status.
  836  */
  837 int
sdla_read_int_stat(void *phw, u_int32_t *int_status)
  839 {
sdlahw_card_t*  card = NULL;
sdlahw_t*       hw = (sdlahw_t*)phw;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
card = hw->hwcard;
  847         switch (card->type) {
  848         case SDLA_AFT:
sdla_pci_read_config_dword(hw, PCI_INT_STATUS, int_status);
  850         }
  851         return (0);
  852 }
  855 /*
  856  * Generate an interrupt to adapter's CPU.
  857  */
  858 int
sdla_cmd(void *phw, unsigned long offset, wan_mbox_t *mbox)
  860 {
sdlahw_t        *hw = (sdlahw_t*)phw;
  862         int              len = sizeof(wan_cmd_t);
  863         int              err = 0;
u_int8_t         value;
SDLA_MAGIC(hw);
len += mbox->wan_data_len;
sdla_peek(hw, offset, (void*)&value, 1);
  870         if (value != 0x00) {
log(LOG_INFO, "%s: opp flag set on entry to sdla_exec!\n",
hw->devname);
  873                 return (0);
  874         }
mbox->wan_opp_flag = 0x00;
sdla_poke(hw, offset, (void*)mbox, len);
err = sdla_exec(hw, offset);
  879         if (!err) {
log(LOG_INFO, "%s: Command 0x%02X failed!\n",
hw->devname, mbox->wan_command);
  882                 return (WAN_CMD_TIMEOUT);
  883         }
sdla_peek(hw, offset, (void*)mbox, sizeof(wan_cmd_t));
  885         if (mbox->wan_data_len) {
sdla_peek(hw, offset+offsetof(wan_mbox_t, wan_data),
mbox->wan_data, mbox->wan_data_len);
  888         }
  890         return (mbox->wan_return_code);
  891 }
  893 /*
  894  * Execute Adapter Command.
  895  * o Set exec flag.
  896  * o Busy-wait until flag is reset.
  897  * o Return number of loops made, or 0 if command timed out.
  898  */
  899 static int
sdla_exec(sdlahw_t *hw, unsigned long offset)
  901 {
  902         volatile unsigned long  tstop;
  903         volatile unsigned long  nloops;
u_int8_t                value;
value = 0x01;
sdla_poke(hw, offset, (void*)&value, 1);
tstop = ticks + EXEC_TIMEOUT;
sdla_peek(hw, offset, (void*)&value, 1);
  911         for (nloops = 1; value == 0x01; ++ nloops) {
DELAY(EXEC_DELAY);
  913                 if (ticks > tstop || nloops > MAX_NLOOPS) {
log(LOG_INFO, "%s: Timeout %lu ticks (max=%lu) "
  915                             "loops %lu (max=%u)\n", hw->devname,
  916                             (ticks-tstop+EXEC_TIMEOUT),
  917                             (unsigned long)EXEC_TIMEOUT, nloops, MAX_NLOOPS);
  918                         return (0);             /* time is up! */
  919                 }
sdla_peek(hw, offset, (void*)&value, 1);
  921         }
  923         return (nloops);
  924 }
  927 /*
  928  * Read absolute adapter memory.
  929  * Transfer data from adapter's memory to data buffer.
  930  *
  931  * Note:
  932  * Care should be taken when crossing dual-port memory window boundary.
  933  * This function is not atomic, so caller must disable interrupt if
  934  * interrupt routines are accessing adapter shared memory.
  935  */
  936 int
sdla_peek(void *phw, unsigned long addr, void *buf, unsigned len)
  938 {
sdlahw_card_t*  card = NULL;
sdlahw_t*       hw = (sdlahw_t*)phw;
  941         int err = 0;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
card = hw->hwcard;
  947         if (addr + len > hw->memory)    /* verify arguments */
  948                 return (EINVAL);
  950         switch (card->type) {
  951         case SDLA_AFT:
sdla_peek_by_4(hw, addr, buf, len);
  953                 break;
  955         default:
log(LOG_INFO, "%s: Invalid card type 0x%X\n",
__FUNCTION__,card->type);
err = (EINVAL);
  959                 break;
  960         }
  961         return (err);
  962 }
  965 /*
  966  * Read data from adapter's memory to a data buffer in 4-byte chunks.
  967  * Note that we ensure that the SDLA memory address is on a 4-byte boundary
  968  * before we begin moving the data in 4-byte chunks.
  969 */
  970 static void
sdla_peek_by_4(sdlahw_t *hw, unsigned long offset, void *buf, unsigned int len)
  972 {
  973         /* byte copy data until we get to a 4-byte boundary */
  974         while (len && (offset & 0x03)) {
sdla_bus_read_1(hw, offset++, (u_int8_t*)buf);
  976                 ((u_int8_t *)buf)++;
len--;
  978         }
  980         /* copy data in 4-byte chunks */
  981         while (len >= 4) {
sdla_bus_read_4(hw, offset, (u_int32_t*)buf);
  983                 (u_int8_t*)buf += 4;
offset += 4;
len -= 4;
  986         }
  988         /* byte copy any remaining data */
  989         while (len) {
sdla_bus_read_1(hw, offset++, (u_int8_t*)buf);
  991                 ((u_int8_t *)buf)++;
len--;
  993         }
  994 }
  996 /*
  997  * Write Absolute Adapter Memory.
  998  * Transfer data from data buffer to adapter's memory.
  999  *
 1000  * Note:
 1001  * Care should be taken when crossing dual-port memory window boundary.
 1002  * This function is not atomic, so caller must disable interrupt if
 1003  * interrupt routines are accessing adapter shared memory.
 1004  */
 1005 int
sdla_poke(void *phw, unsigned long addr, void *buf, unsigned len)
 1007 {
sdlahw_card_t*  card = NULL;
sdlahw_t*       hw = (sdlahw_t*)phw;
 1010         int err = 0;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
card = hw->hwcard;
 1016         if (addr + len > hw->memory) {  /* verify arguments */
 1017                 return (EINVAL);
 1018         }
 1020         switch (card->type) {
 1021         case SDLA_AFT:
sdla_poke_by_4(hw, addr, buf, len);
 1023                 break;
 1025         default:
log(LOG_INFO, "%s: Invalid card type 0x%X\n",
__FUNCTION__,card->type);
err = (EINVAL);
 1029                 break;
 1030         }
 1031         return (err);
 1032 }
 1035 /*
 1036  * Write from a data buffer to adapter's memory in 4-byte chunks.
 1037  * Note that we ensure that the SDLA memory address is on a 4-byte boundary
 1038  * before we begin moving the data in 4-byte chunks.
 1039 */
 1040 static void
sdla_poke_by_4(sdlahw_t *hw, unsigned long offset, void *buf, unsigned int len)
 1042 {
 1043         /* byte copy data until we get to a 4-byte boundary */
 1044         while (len && (offset & 0x03)) {
sdla_bus_write_1(hw, offset++, *(char *)buf);
 1046                 ((char *)buf) ++;
len --;
 1048         }
 1050         /* copy data in 4-byte chunks */
 1051         while (len >= 4) {
sdla_bus_write_4(hw, offset, *(unsigned long *)buf);
offset += 4;
 1054                 (char*)buf += 4;
len -= 4;
 1056         }
 1058         /* byte copy any remaining data */
 1059         while (len) {
sdla_bus_write_1(hw, offset++, *(char *)buf);
 1061                 ((char *)buf) ++;
len --;
 1063         }
 1064 }
 1066 int
sdla_poke_byte(void *phw, unsigned long offset, u_int8_t value)
 1068 {
sdlahw_t *hw = (sdlahw_t*)phw;
SDLA_MAGIC(hw);
 1072         /* Sangoma ISA card sdla_bus_write_1(hw, offset, value); */
sdla_poke(hw, offset, (void*)&value, 1);
 1074         return (0);
 1075 }
 1077 int
sdla_set_bit(void *phw, unsigned long offset, u_int8_t value)
 1079 {
sdlahw_t        *hw = (sdlahw_t*)phw;
u_int8_t         tmp;
SDLA_MAGIC(hw);
 1084         /* Sangoma ISA card -> sdla_bus_read_1(hw, offset, &tmp); */
sdla_peek(hw, offset, (void*)&tmp, 1);
tmp |= value;
 1087         /* Sangoma ISA card -> sdla_bus_write_1(hw, offset, tmp); */
sdla_poke(hw, offset, (void*)&tmp, 1);
 1089         return (0);
 1090 }
 1092 int
sdla_clear_bit(void *phw, unsigned long offset, u_int8_t value)
 1094 {
sdlahw_t        *hw = (sdlahw_t*)phw;
u_int8_t         tmp;
SDLA_MAGIC(hw);
 1099         /* Sangoma ISA card -> sdla_bus_read_1(hw, offset, &tmp); */
sdla_peek(hw, offset, (void*)&tmp, 1);
tmp &= ~value;
 1102         /* Sangoma ISA card -> sdla_bus_write_1(hw, offset, tmp); */
sdla_poke(hw, offset, (void*)&tmp, 1);
 1104         return (0);
 1105 }
 1107 /*
 1108  * Find the AFT HDLC PCI adapter in the PCI bus.
 1109  * Return the number of AFT adapters found (0 if no adapter found).
 1110  */
 1111 static int
sdla_detect_aft(sdlahw_t *hw)
 1113 {
sdlahw_card_t   *card;
u_int16_t        ut_u16;
WAN_ASSERT(hw == NULL);
WAN_ASSERT(hw->hwcard == NULL);
card = hw->hwcard;
sdla_pci_read_config_dword(hw,
 1121             (hw->cpu_no == SDLA_CPU_A) ? PCI_IO_BASE_DWORD :
PCI_MEM_BASE0_DWORD, (u_int32_t*)&hw->mem_base_addr);
 1123         if (!hw->mem_base_addr) {
 1124                 if (hw->cpu_no == SDLA_CPU_B) {
printf("%s: No PCI memory allocated for CPU #B\n",
hw->devname);
 1127                 } else {
printf("%s: No PCI memory allocated to card\n",
hw->devname);
 1130                 }
 1131                 return (EINVAL);
 1132         }
 1133 #ifdef DEBUG
log(LOG_INFO,  "%s: AFT PCI memory at 0x%lX\n",
hw->devname, (unsigned long)hw->mem_base_addr);
 1136 #endif /* DEBUG */
sdla_pci_read_config_byte(hw, PCI_INTLINE, (u_int8_t*)&hw->irq);
 1138         if (hw->irq == PCI_IRQ_NOT_ALLOCATED) {
printf("%s: IRQ not allocated to AFT adapter\n", hw->devname);
 1140                 return (EINVAL);
 1141         }
 1143 #ifdef DEBUG
log(LOG_INFO, "%s: IRQ %d allocated to the AFT PCI card\n",
hw->devname, hw->irq);
 1146 #endif /* DEBUG */
hw->memory=XILINX_PCI_MEM_SIZE;
 1150         /* Map the physical PCI memory to virtual memory */
bus_space_map(hw->hwcard->memt, hw->mem_base_addr, XILINX_PCI_MEM_SIZE,
 1152             0, &hw->dpmbase);
 1153         if (!hw->dpmbase) {
printf("%s: couldn't map memory\n", hw->devname);
 1155                 return (EINVAL);
 1156         }
hw->status |= SDLA_MEM_MAPPED;
 1160         /* Enable master operation on PCI and enable bar0 memory */
sdla_pci_read_config_word(hw, XILINX_PCI_CMD_REG, &ut_u16);
ut_u16 |=0x06;
sdla_pci_write_config_word(hw, XILINX_PCI_CMD_REG, ut_u16);
 1165         /* Set PCI Latency of 0xFF*/
sdla_pci_write_config_dword(hw, XILINX_PCI_LATENCY_REG,
XILINX_PCI_LATENCY);
 1169         return (0);
 1170 }
 1173 /*
 1174  * Detect adapter type.
 1175  */
 1176 static int
sdla_detect(sdlahw_t *hw)
 1178 {
sdlahw_card_t   *card = NULL;
 1180         int              err = 0;
WAN_ASSERT(hw == NULL);
WAN_ASSERT(hw->hwcard == NULL);
card = hw->hwcard;
 1185         switch (card->type) {
 1186         case SDLA_AFT:
err = sdla_detect_aft(hw);
 1188                 break;
 1189         }
 1190         if (err)
sdla_down(hw);
 1193         return (err);
 1194 }
 1196 int
sdla_is_te1(void *phw)
 1198 {
sdlahw_card_t   *hwcard = NULL;
sdlahw_t        *hw = (sdlahw_t*)phw;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
hwcard = hw->hwcard;
 1206         switch (hwcard->atype) {
 1207         case S5144_ADPTR_1_CPU_T1E1:
 1208         case S5147_ADPTR_2_CPU_T1E1:
 1209         case S5148_ADPTR_1_CPU_T1E1:
 1210         case A101_ADPTR_1TE1:
 1211         case A101_ADPTR_2TE1:
 1212                 return (1);
 1213         }
 1214         return (0);
 1215 }
 1217 int
sdla_check_mismatch(void *phw, unsigned char media)
 1219 {
sdlahw_card_t   *hwcard = NULL;
sdlahw_t        *hw = (sdlahw_t*)phw;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
hwcard = hw->hwcard;
 1227         if (media == WAN_MEDIA_T1 ||
media == WAN_MEDIA_E1) {
 1229                 if (hwcard->atype != S5144_ADPTR_1_CPU_T1E1 &&
hwcard->atype != S5147_ADPTR_2_CPU_T1E1 &&
hwcard->atype != S5148_ADPTR_1_CPU_T1E1) {
log(LOG_INFO, "%s: Error: Card type mismatch: "
 1233                             "User=T1/E1 Actual=%s\n", hw->devname,
SDLA_ADPTR_DECODE(hwcard->atype));
 1235                         return (EIO);
 1236                 }
hwcard->atype = S5144_ADPTR_1_CPU_T1E1;
 1239         } else if (media == WAN_MEDIA_56K) {
 1240                 if (hwcard->atype != S5145_ADPTR_1_CPU_56K) {
log(LOG_INFO, "%s: Error: Card type mismatch: "
 1242                             "User=56K Actual=%s\n", hw->devname,
SDLA_ADPTR_DECODE(hwcard->atype));
 1244                         return (EIO);
 1245                 }
 1246         } else {
 1247                 if (hwcard->atype == S5145_ADPTR_1_CPU_56K ||
hwcard->atype == S5144_ADPTR_1_CPU_T1E1 ||
hwcard->atype == S5147_ADPTR_2_CPU_T1E1 ||
hwcard->atype == S5148_ADPTR_1_CPU_T1E1) {
log(LOG_INFO, "%s: Error: Card type mismatch: "
 1252                             "User=S514(1/2/3) Actual=%s\n", hw->devname,
SDLA_ADPTR_DECODE(hwcard->atype));
 1254                         return (EIO);
 1255                 }
 1256         }
 1258         return (0);
 1259 }
 1261 int
sdla_getcfg(void *phw, int type, void *value)
 1263 {
sdlahw_t*       hw = (sdlahw_t*)phw;
sdlahw_card_t *hwcard;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
hwcard = hw->hwcard;
 1271         switch (type) {
 1272         case SDLA_CARDTYPE:
 1273                 *(u_int16_t*)value = hwcard->type;
 1274                 break;
 1275         case SDLA_MEMBASE:
 1276                 *(bus_space_handle_t*)value = hw->dpmbase;
 1277                 break;
 1278         case SDLA_MEMEND:
 1279                 *(u_int32_t*)value = ((unsigned long)hw->dpmbase +
hw->dpmsize - 1);
 1281                 break;
 1282         case SDLA_MEMSIZE:
 1283                 *(u_int16_t*)value = hw->dpmsize;
 1284                 break;
 1285         case SDLA_MEMORY:
 1286                 *(u_int32_t*)value = hw->memory;
 1287                 break;
 1288         case SDLA_IRQ:
 1289                 *(u_int16_t*)value = hw->irq;
 1290                 break;
 1291         case SDLA_ADAPTERTYPE:
 1292                 *(u_int16_t*)value = hwcard->atype;
 1293                 break;
 1294         case SDLA_CPU:
 1295                 *(u_int16_t*)value = hw->cpu_no;
 1296                 break;
 1297         case SDLA_SLOT:
 1298                 *(u_int16_t*)value = hwcard->slot_no;
 1299                 break;
 1300         case SDLA_BUS:
 1301                 *(u_int16_t*)value = hwcard->bus_no;
 1302                 break;
 1303         case SDLA_DMATAG:
 1304                 *(bus_dma_tag_t*)value = hwcard->pa.pa_dmat;
 1305                 break;
 1306         case SDLA_PCIEXTRAVER:
 1307                 *(u_int8_t*)value = hwcard->pci_extra_ver;
 1308                 break;
 1309         case SDLA_BASEADDR:
 1310                 *(u_int32_t*)value = hw->mem_base_addr;
 1311                 break;
 1312         }
 1313         return (0);
 1314 }
 1317 int
sdla_get_hwcard(void *phw, void **phwcard)
 1319 {
sdlahw_t *hw = (sdlahw_t*)phw;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
 1325         *phwcard = hw->hwcard;
 1326         return (0);
 1327 }
 1330 int
sdla_get_hwprobe(void *phw, void **str)
 1332 {
sdlahw_t *hw = (sdlahw_t*)phw;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
 1338         if (hw->hwprobe)
 1339                 *str = hw->hwprobe->hw_info;
 1341         return (0);
 1342 }
 1344 int
sdla_bus_write_1(void *phw, unsigned int offset, u_int8_t value)
 1346 {
sdlahw_t *hw = (sdlahw_t*)phw;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
 1351         if (!(hw->status & SDLA_MEM_MAPPED))
 1352                 return (0);
bus_space_write_1(hw->hwcard->memt, hw->dpmbase, offset, value);
 1354         return (0);
 1355 }
 1357 int
sdla_bus_write_2(void *phw, unsigned int offset, u_int16_t value)
 1359 {
sdlahw_t *hw = (sdlahw_t*)phw;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
 1364         if (!(hw->status & SDLA_MEM_MAPPED))
 1365                 return (0);
bus_space_write_2(hw->hwcard->memt, hw->dpmbase, offset, value);
 1367         return (0);
 1368 }
 1370 int
sdla_bus_write_4(void *phw, unsigned int offset, u_int32_t value)
 1372 {
sdlahw_t *hw = (sdlahw_t*)phw;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
 1377         if (!(hw->status & SDLA_MEM_MAPPED))
 1378                 return (0);
bus_space_write_4(hw->hwcard->memt, hw->dpmbase, offset, value);
 1380         return (0);
 1381 }
 1383 int
sdla_bus_read_1(void *phw, unsigned int offset, u_int8_t *value)
 1385 {
sdlahw_t *hw = (sdlahw_t*)phw;
WAN_ASSERT2(hw == NULL, 0);
SDLA_MAGIC(hw);
 1390         if (!(hw->status & SDLA_MEM_MAPPED))
 1391                 return (0);
 1392         *value = bus_space_read_1(hw->hwcard->memt, hw->dpmbase, offset);
 1393         return (0);
 1394 }
 1396 int
sdla_bus_read_2(void *phw, unsigned int offset, u_int16_t *value)
 1398 {
sdlahw_t *hw = (sdlahw_t*)phw;
WAN_ASSERT2(hw == NULL, 0);
SDLA_MAGIC(hw);
 1403         if (!(hw->status & SDLA_MEM_MAPPED))
 1404                 return (0);
 1405         *value = bus_space_read_2(hw->hwcard->memt, hw->dpmbase, offset);
 1406         return (0);
 1407 }
 1409 int
sdla_bus_read_4(void *phw, unsigned int offset, u_int32_t *value)
 1411 {
sdlahw_t *hw = (sdlahw_t*)phw;
WAN_ASSERT2(hw == NULL, 0);
WAN_ASSERT2(hw->dpmbase == 0, 0);
SDLA_MAGIC(hw);
 1417         if (!(hw->status & SDLA_MEM_MAPPED))
 1418                 return (0);
 1419         *value = bus_space_read_4(hw->hwcard->memt, hw->dpmbase, offset);
 1420         return (0);
 1421 }
 1423 static int
sdla_pci_read_config_dword(void *phw, int reg, u_int32_t *value)
 1425 {
sdlahw_t        *hw = (sdlahw_t*)phw;
sdlahw_card_t   *hwcard;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
hwcard = hw->hwcard;
 1433         *value = pci_conf_read(hwcard->pa.pa_pc, hwcard->pa.pa_tag, reg);
 1434         return (0);
 1435 }
 1437 static int
sdla_pci_read_config_word(void *phw, int reg, u_int16_t *value)
 1439 {
sdlahw_t        *hw = (sdlahw_t*)phw;
sdlahw_card_t   *hwcard;
u_int32_t        tmp = 0x00;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
hwcard = hw->hwcard;
tmp = pci_conf_read(hwcard->pa.pa_pc, hwcard->pa.pa_tag, reg);
 1449         *value = (u_int16_t)((tmp >> 16) & 0xFFFF);
 1450         return (0);
 1451 }
 1453 static int
sdla_pci_read_config_byte(void *phw, int reg, u_int8_t *value)
 1455 {
sdlahw_t        *hw = (sdlahw_t*)phw;
sdlahw_card_t   *hwcard;
u_int32_t        tmp = 0x00;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
hwcard = hw->hwcard;
tmp = pci_conf_read(hwcard->pa.pa_pc, hwcard->pa.pa_tag, reg);
 1465         *value = (u_int8_t)(tmp & 0xFF);
 1466         return (0);
 1467 }
 1469 static int
sdla_pci_write_config_dword(void *phw, int reg, u_int32_t value)
 1471 {
sdlahw_t *hw = (sdlahw_t*)phw;
sdlahw_card_t *card;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
card = hw->hwcard;
pci_conf_write(card->pa.pa_pc, card->pa.pa_tag, reg, value);
 1480         return (0);
 1481 }
 1483 static int
sdla_pci_write_config_word(void *phw, int reg, u_int16_t value)
 1485 {
sdlahw_t *hw = (sdlahw_t*)phw;
sdlahw_card_t *card;
WAN_ASSERT(hw == NULL);
SDLA_MAGIC(hw);
WAN_ASSERT(hw->hwcard == NULL);
card = hw->hwcard;
pci_conf_write(card->pa.pa_pc, card->pa.pa_tag, reg, value);
 1494         return (0);
 1495 }