Annotation of sys/dev/pci/if_sandrv.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: if_sandrv.c,v 1.11 2006/04/20 20:31:12 miod Exp $ */
! 2:
! 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: */
! 34:
! 35: #define __SDLA_HW_LEVEL
! 36: #define __SDLADRV__
! 37:
! 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>
! 44:
! 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>
! 49:
! 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 */
! 57:
! 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 */
! 62:
! 63: #define IS_SUPPORTED_ADAPTER(hw) ((hw)->type == SDLA_AFT)
! 64:
! 65: #define SDLA_CTYPE_NAME(type) \
! 66: ((type) == SDLA_AFT) ? "AFT" : "Unknown"
! 67:
! 68: #define IS_AFT(hw) (hw->type == SDLA_AFT)
! 69:
! 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 */
! 74:
! 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 */
! 79:
! 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 */
! 83:
! 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, \
! 87: PCI_SUBSYS_ID_REG) & PCI_SUBVENDOR_MASK)
! 88: #define PCI_DEVICE_MASK 0xFFFF0000
! 89: #define PCI_DEVICE(id) ((id & PCI_DEVICE_MASK ) >> 16)
! 90:
! 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
! 96:
! 97: struct san_softc {
! 98: struct device dev;
! 99: struct pci_attach_args pa;
! 100: };
! 101:
! 102: typedef struct sdla_hw_probe {
! 103: int used;
! 104: unsigned char hw_info[100];
! 105: LIST_ENTRY(sdla_hw_probe) next;
! 106: } sdla_hw_probe_t;
! 107:
! 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;
! 120: bus_space_tag_t memt;
! 121: struct pci_attach_args pa; /* PCI config header info */
! 122: pci_intr_handle_t ih;
! 123: LIST_ENTRY(sdlahw_card) next;
! 124: } sdlahw_card_t;
! 125:
! 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];
! 134: 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 */
! 138: bus_addr_t mem_base_addr;
! 139: bus_space_handle_t dpmbase; /* dual-port memory base */
! 140: unsigned dpmsize; /* dual-port memory size */
! 141: unsigned long memory; /* memory size */
! 142:
! 143: unsigned reserved[5];
! 144: unsigned char hw_info[100];
! 145:
! 146: u_int16_t configured;
! 147: void *arg; /* card structure */
! 148: sdla_hw_probe_t *hwprobe;
! 149: sdlahw_card_t *hwcard;
! 150: LIST_ENTRY(sdlahw) next;
! 151: } sdlahw_t;
! 152:
! 153: /* Entry Point for Low-Level function */
! 154: int sdladrv_init(void);
! 155: int sdladrv_exit(void);
! 156:
! 157: static int sdla_pci_probe(int, struct pci_attach_args *);
! 158:
! 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 *);
! 165:
! 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);
! 171:
! 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);
! 177:
! 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);
! 183:
! 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);
! 187:
! 188: /* SDLA PCI device relative entry point */
! 189: int san_match(struct device *, void *, void *);
! 190: void san_attach(struct device *, struct device *, void *);
! 191:
! 192:
! 193: struct cfdriver san_cd = {
! 194: NULL, "san", DV_IFNET
! 195: };
! 196:
! 197: struct cfattach san_ca = {
! 198: sizeof(struct san_softc), san_match, san_attach
! 199: };
! 200:
! 201: extern int ticks;
! 202:
! 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;
! 207:
! 208: /* private data */
! 209: char *san_drvname = "san";
! 210:
! 211: /* Array of already initialized PCI slots */
! 212: static int pci_slot_ar[MAX_S514_CARDS];
! 213:
! 214: LIST_HEAD(, sdlahw_card) sdlahw_card_head =
! 215: LIST_HEAD_INITIALIZER(sdlahw_card_head);
! 216: LIST_HEAD(, sdlahw) sdlahw_head =
! 217: LIST_HEAD_INITIALIZER(sdlahw_head);
! 218: LIST_HEAD(, sdla_hw_probe) sdlahw_probe_head =
! 219: LIST_HEAD_INITIALIZER(sdlahw_probe_head);
! 220: static sdla_hw_type_cnt_t sdla_adapter_cnt;
! 221:
! 222:
! 223:
! 224: /*
! 225: * PCI Device Driver Entry Points
! 226: */
! 227: int
! 228: san_match(struct device *parent, void *match, void *aux)
! 229: {
! 230: struct pci_attach_args* pa = aux;
! 231: u_int16_t vendor_id = PCI_VENDOR(pa->pa_id);
! 232: u_int16_t device_id = PCI_DEVICE(pa->pa_id);
! 233:
! 234: if ((vendor_id == SANGOMA_PCI_VENDOR ||
! 235: vendor_id == SANGOMA_PCI_VENDOR_OLD) &&
! 236: device_id == SANGOMA_PCI_DEVICE) {
! 237: return (1);
! 238: }
! 239: return (0);
! 240: }
! 241:
! 242: #define PCI_CBIO 0x10
! 243: void
! 244: san_attach(struct device *parent, struct device *self, void *aux)
! 245: {
! 246: struct pci_attach_args* pa = aux;
! 247: u_int16_t vendor_id = PCI_VENDOR(pa->pa_id);
! 248: u_int16_t subvendor_id = PCI_SUBVENDOR(pa);
! 249: int atype = 0x00;
! 250:
! 251: atype = PCI_PRODUCT(pci_conf_read(pa->pa_pc, pa->pa_tag,
! 252: 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:
! 258: atype = A101_ADPTR_1TE1;
! 259: break;
! 260: case A101_2TE1_SUBSYS_VENDOR:
! 261: atype = A101_ADPTR_2TE1;
! 262: break;
! 263: default:
! 264: return;
! 265: }
! 266: break;
! 267: default:
! 268: return;
! 269: }
! 270:
! 271: if (sdla_pci_probe(atype, pa)) {
! 272: printf(": PCI probe FAILED!\n");
! 273: return;
! 274: }
! 275:
! 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:
! 281: log(LOG_INFO, "%s: Sangoma S5141/FT1 (Single CPU) "
! 282: "adapter\n", self->dv_xname);
! 283: break;
! 284: case S5142_ADPTR_2_CPU_SERIAL:
! 285: log(LOG_INFO, "%s: Sangoma S5142 (Dual CPU) adapter\n",
! 286: self->dv_xname);
! 287: break;
! 288: case S5143_ADPTR_1_CPU_FT1:
! 289: 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:
! 294: 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:
! 298: log(LOG_INFO, "%s: Sangoma S5145 (Single CPU) "
! 299: "56K adapter\n", self->dv_xname);
! 300: break;
! 301: case S5147_ADPTR_2_CPU_T1E1:
! 302: log(LOG_INFO, "%s: Sangoma S5147 (Dual CPU) "
! 303: "T1/E1 adapter\n", self->dv_xname);
! 304: break;
! 305: }
! 306: break;
! 307:
! 308: case SANGOMA_PCI_VENDOR_OLD:
! 309: switch (atype) {
! 310: case A101_ADPTR_1TE1:
! 311: log(LOG_INFO, "%s: Sangoma AFT (1 channel) "
! 312: "T1/E1 adapter\n", self->dv_xname);
! 313: break;
! 314: case A101_ADPTR_2TE1:
! 315: 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: }
! 324:
! 325: /*
! 326: * Module init point.
! 327: */
! 328: int
! 329: sdladrv_init(void)
! 330: {
! 331: int volatile i = 0;
! 332:
! 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++)
! 337: pci_slot_ar[i] = 0xFF;
! 338:
! 339: bzero(&sdla_adapter_cnt, sizeof(sdla_hw_type_cnt_t));
! 340:
! 341: return (0);
! 342: }
! 343:
! 344: /*
! 345: * Module deinit point.
! 346: * o release all remaining system resources
! 347: */
! 348: int
! 349: sdladrv_exit(void)
! 350: {
! 351: #if 0
! 352: sdla_hw_probe_t *elm_hw_probe;
! 353: sdlahw_t *elm_hw;
! 354: sdlahw_card_t *elm_hw_card;
! 355:
! 356:
! 357: elm_hw = LIST_FIRST(&sdlahw_head);
! 358: while (elm_hw) {
! 359: sdlahw_t *tmp = elm_hw;
! 360: elm_hw = LIST_NEXT(elm_hw, next);
! 361: if (sdla_hw_unregister(tmp->hwcard, tmp->cpu_no) == EBUSY)
! 362: return EBUSY;
! 363: }
! 364: LIST_INIT(&sdlahw_head);
! 365:
! 366: elm_hw_card = LIST_FIRST(&sdlahw_card_head);
! 367: while (elm_hw_card) {
! 368: sdlahw_card_t *tmp = elm_hw_card;
! 369: elm_hw_card = LIST_NEXT(elm_hw_card, next);
! 370: if (sdla_card_unregister(tmp->hw_type,
! 371: tmp->slot_no,
! 372: tmp->bus_no,
! 373: tmp->ioport) == EBUSY)
! 374: return EBUSY;
! 375: }
! 376: LIST_INIT(&sdlahw_card_head);
! 377:
! 378: elm_hw_probe = LIST_FIRST(&sdlahw_probe_head);
! 379: while (elm_hw_probe) {
! 380: sdla_hw_probe_t *tmp = elm_hw_probe;
! 381: elm_hw_probe = LIST_NEXT(elm_hw_probe, next);
! 382: if (tmp->used){
! 383: log(LOG_INFO, "HW probe info is in used (%s)\n",
! 384: elm_hw_probe->hw_info);
! 385: return EBUSY;
! 386: }
! 387: LIST_REMOVE(tmp, next);
! 388: free(tmp, M_DEVBUF);
! 389: }
! 390: #endif
! 391: return (0);
! 392: }
! 393:
! 394: static void
! 395: sdla_save_hw_probe(sdlahw_t *hw, int port)
! 396: {
! 397: sdla_hw_probe_t *tmp_hw_probe;
! 398:
! 399: tmp_hw_probe = malloc(sizeof(sdla_hw_probe_t), M_DEVBUF, M_NOWAIT);
! 400: if (tmp_hw_probe == NULL)
! 401: return;
! 402:
! 403: bzero(tmp_hw_probe, sizeof(sdla_hw_probe_t));
! 404:
! 405: snprintf(tmp_hw_probe->hw_info, sizeof(tmp_hw_probe->hw_info),
! 406: "%s : SLOT=%d : BUS=%d : IRQ=%d : CPU=%c : PORT=%s",
! 407: SDLA_ADPTR_DECODE(hw->hwcard->atype), hw->hwcard->slot_no,
! 408: hw->hwcard->bus_no, hw->irq, SDLA_GET_CPU(hw->cpu_no), "PRI");
! 409:
! 410: hw->hwprobe = tmp_hw_probe;
! 411: tmp_hw_probe->used++;
! 412: LIST_INSERT_HEAD(&sdlahw_probe_head, tmp_hw_probe, next);
! 413: }
! 414:
! 415: static sdlahw_t*
! 416: sdla_aft_hw_select(sdlahw_card_t *hwcard, int cpu_no,
! 417: int irq, struct pci_attach_args *pa)
! 418: {
! 419: sdlahw_t* hw = NULL;
! 420: int number_of_cards = 0;
! 421:
! 422: hwcard->type = SDLA_AFT;
! 423: switch (hwcard->atype) {
! 424: case A101_ADPTR_1TE1:
! 425: hw = sdla_hw_register(hwcard, cpu_no, irq, pa);
! 426: sdla_save_hw_probe(hw, 0);
! 427: number_of_cards += 1;
! 428: #ifdef DEBUG
! 429: 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,
! 431: SDLA_ADPTR_DECODE(hwcard->atype),
! 432: AFT_CORE_ID_DECODE(hwcard->core_id), hwcard->core_rev,
! 433: hwcard->bus_no, hwcard->slot_no, irq);
! 434: #endif /* DEBUG */
! 435: break;
! 436: case A101_ADPTR_2TE1:
! 437: hw = sdla_hw_register(hwcard, cpu_no, irq, pa);
! 438: sdla_save_hw_probe(hw, 0);
! 439: number_of_cards += 1;
! 440: #ifdef DEBUG
! 441: 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,
! 443: SDLA_ADPTR_DECODE(hwcard->atype),
! 444: AFT_CORE_ID_DECODE(hwcard->core_id), hwcard->core_rev,
! 445: hwcard->bus_no, hwcard->slot_no, irq);
! 446: #endif /* DEBUG */
! 447: break;
! 448: case A105_ADPTR_1_CHN_T3E3:
! 449:
! 450: hw = sdla_hw_register(hwcard, cpu_no, irq, pa);
! 451: sdla_save_hw_probe(hw, 0);
! 452: number_of_cards += 1;
! 453: #ifdef DEBUG
! 454: log(LOG_INFO, "%s: %s T3/E3 card found, cpu(s) 1,"
! 455: "bus #%d, slot #%d, irq #%d\n", san_drvname,
! 456: SDLA_ADPTR_DECODE(hwcard->atype),
! 457: hwcard->bus_no, hwcard->slot_no, irq);
! 458: #endif /* DEBUG */
! 459: break;
! 460: default:
! 461: log(LOG_INFO, "%s: Unknown adapter %04X "
! 462: "(bus #%d, slot #%d, irq #%d)!\n", san_drvname,
! 463: hwcard->atype, hwcard->bus_no, hwcard->slot_no, irq);
! 464: break;
! 465: }
! 466:
! 467: return (hw);
! 468: }
! 469:
! 470:
! 471: static int
! 472: sdla_pci_probe(int atype, struct pci_attach_args *pa)
! 473: {
! 474: sdlahw_card_t* hwcard;
! 475: sdlahw_t* hw;
! 476: /*sdladev_t* dev = NULL;*/
! 477: int dual_cpu = 0;
! 478: int bus, slot, cpu = SDLA_CPU_A;
! 479: u_int16_t vendor_id, subvendor_id, device_id;
! 480: u_int8_t irq;
! 481: pci_intr_handle_t ih;
! 482: const char* intrstr = NULL;
! 483:
! 484: bus = pa->pa_bus;
! 485: slot = pa->pa_device;
! 486: vendor_id = PCI_VENDOR(pa->pa_id);
! 487: subvendor_id = PCI_SUBVENDOR(pa);
! 488: device_id = PCI_DEVICE(pa->pa_id);
! 489: irq = (u_int8_t)pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_INTLINE);
! 490:
! 491: /* Map and establish the interrupt */
! 492: if (pci_intr_map(pa, &ih)) {
! 493: printf(": couldn't map interrupt\n");
! 494: return (EINVAL);
! 495: }
! 496: intrstr = pci_intr_string(pa->pa_pc, ih);
! 497: if (intrstr != NULL)
! 498: printf(" %s\n", intrstr);
! 499:
! 500: Sangoma_cards_no ++;
! 501: reg_new_card:
! 502: Sangoma_PCI_cards_no ++;
! 503: hwcard = sdla_card_register(atype, slot, bus);
! 504: if (hwcard == NULL)
! 505: return (EINVAL);
! 506:
! 507: hwcard->memt = pa->pa_memt;
! 508: hwcard->ih = ih;
! 509: hwcard->pa = *pa;
! 510: /* Increment number of available Sangoma devices */
! 511: Sangoma_devices_no ++;
! 512: switch (atype) {
! 513: case A101_ADPTR_1TE1:
! 514: case A101_ADPTR_2TE1:
! 515: hw = sdla_aft_hw_select(hwcard, cpu, irq, pa);
! 516: sdla_adapter_cnt.AFT_adapters++;
! 517: if (atype == A101_ADPTR_2TE1)
! 518: dual_cpu = 1;
! 519: break;
! 520:
! 521: }
! 522:
! 523: if (hw == NULL)
! 524: return (EINVAL);
! 525: if (san_dev_attach(hw, hw->devname, sizeof(hw->devname)))
! 526: return (EINVAL);
! 527:
! 528: hw->used++;
! 529:
! 530: if (dual_cpu && cpu == SDLA_CPU_A) {
! 531: cpu = SDLA_CPU_B;
! 532: goto reg_new_card;
! 533: }
! 534:
! 535: return (0);
! 536: }
! 537:
! 538: int
! 539: sdla_intr_establish(void *phw, int (*intr_func)(void*), void* intr_arg)
! 540: {
! 541: sdlahw_t *hw = (sdlahw_t*)phw;
! 542: sdlahw_card_t *hwcard;
! 543:
! 544: WAN_ASSERT(hw == NULL);
! 545: hwcard = hw->hwcard;
! 546: if (pci_intr_establish(hwcard->pa.pa_pc, hwcard->ih, IPL_NET,
! 547: intr_func, intr_arg, "san") == NULL)
! 548: return (EINVAL);
! 549:
! 550: return 0;
! 551: }
! 552:
! 553: int
! 554: sdla_intr_disestablish(void *phw)
! 555: {
! 556: sdlahw_t *hw = (sdlahw_t*)phw;
! 557:
! 558: log(LOG_INFO, "%s: Disestablish interrupt is not defined!\n",
! 559: hw->devname);
! 560: return (EINVAL);
! 561: }
! 562:
! 563: int
! 564: sdla_get_hw_devices(void)
! 565: {
! 566: return (Sangoma_devices_no);
! 567: }
! 568:
! 569: void*
! 570: sdla_get_hw_adptr_cnt(void)
! 571: {
! 572: return (&sdla_adapter_cnt);
! 573: }
! 574:
! 575: static sdlahw_card_t*
! 576: sdla_card_register(u_int16_t atype, int slot_no, int bus_no)
! 577: {
! 578: sdlahw_card_t *new_hwcard, *last_hwcard;
! 579:
! 580: new_hwcard = sdla_card_search(atype, slot_no, bus_no);
! 581: if (new_hwcard)
! 582: return (new_hwcard);
! 583:
! 584: new_hwcard = malloc(sizeof(sdlahw_card_t), M_DEVBUF, M_NOWAIT);
! 585: if (!new_hwcard)
! 586: return (NULL);
! 587:
! 588: bzero(new_hwcard, sizeof(sdlahw_card_t));
! 589:
! 590: new_hwcard->atype = atype;
! 591: new_hwcard->slot_no = slot_no;
! 592: new_hwcard->bus_no = bus_no;
! 593:
! 594: if (LIST_EMPTY(&sdlahw_card_head)) {
! 595: /* Initialize SAN HW parameters */
! 596: sdladrv_init();
! 597: }
! 598: LIST_FOREACH(last_hwcard, &sdlahw_card_head, next) {
! 599: if (!LIST_NEXT(last_hwcard, next))
! 600: break;
! 601: }
! 602:
! 603: if (last_hwcard)
! 604: LIST_INSERT_AFTER(last_hwcard, new_hwcard, next);
! 605: else
! 606: LIST_INSERT_HEAD(&sdlahw_card_head, new_hwcard, next);
! 607:
! 608: return (new_hwcard);
! 609: }
! 610:
! 611: #if 0
! 612: static int
! 613: sdla_card_unregister(u_int16_t atype, int slot_no, int bus_no, int ioport)
! 614: {
! 615: sdlahw_card_t* tmp_card;
! 616:
! 617: 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 &&
! 622: tmp_card->bus_no == bus_no){
! 623: break;
! 624: }
! 625: }
! 626: if (tmp_card == NULL){
! 627: log(LOG_INFO,
! 628: "Error: Card didn't find %04X card (slot=%d, bus=%d)\n"
! 629: atype, slot_no, bus_no);
! 630: return (EFAULT)
! 631: }
! 632: if (tmp_card->used){
! 633: log(LOG_INFO,
! 634: "Error: Card is still in used (slot=%d,bus=%d,used=%d)\n",
! 635: slot_no, bus_no, tmp_card->used);
! 636: return (EBUSY);
! 637: }
! 638: LIST_REMOVE(tmp_card, next);
! 639: free(tmp_card, M_DEVBUF);
! 640: return 0;
! 641: }
! 642: #endif
! 643:
! 644: static sdlahw_card_t*
! 645: sdla_card_search(u_int16_t atype, int slot_no, int bus_no)
! 646: {
! 647: sdlahw_card_t* tmp_card;
! 648:
! 649: LIST_FOREACH(tmp_card, &sdlahw_card_head, next) {
! 650: if (tmp_card->atype != atype)
! 651: continue;
! 652:
! 653: if (tmp_card->slot_no == slot_no &&
! 654: tmp_card->bus_no == bus_no)
! 655: return (tmp_card);
! 656: }
! 657: return (NULL);
! 658: }
! 659:
! 660: static sdlahw_t*
! 661: sdla_hw_register(sdlahw_card_t *card, int cpu_no, int irq, void *dev)
! 662: {
! 663: sdlahw_t *new_hw, *last_hw;
! 664:
! 665: new_hw = sdla_hw_search(card->atype, card->slot_no,
! 666: card->bus_no, cpu_no);
! 667: if (new_hw)
! 668: return (new_hw);
! 669:
! 670: new_hw = malloc(sizeof(sdlahw_t), M_DEVBUF, M_NOWAIT);
! 671: if (!new_hw)
! 672: return (NULL);
! 673:
! 674: bzero(new_hw, sizeof(sdlahw_t));
! 675:
! 676: new_hw->cpu_no = cpu_no;
! 677: new_hw->irq = irq;
! 678: new_hw->hwcard = card;
! 679: #if 0
! 680: new_hw->dev = dev;
! 681: #endif
! 682: new_hw->magic = SDLAHW_MAGIC;
! 683: card->used++;
! 684:
! 685: LIST_FOREACH(last_hw, &sdlahw_head, next) {
! 686: if (!LIST_NEXT(last_hw, next))
! 687: break;
! 688: }
! 689: if (last_hw)
! 690: LIST_INSERT_AFTER(last_hw, new_hw, next);
! 691: else
! 692: LIST_INSERT_HEAD(&sdlahw_head, new_hw, next);
! 693:
! 694: return (new_hw);
! 695: }
! 696:
! 697: #if 0
! 698: static int
! 699: sdla_hw_unregister(sdlahw_card_t* hwcard, int cpu_no)
! 700: {
! 701: sdlahw_t* tmp_hw;
! 702: int i;
! 703:
! 704: LIST_FOREACH(tmp_hw, &sdlahw_head, next) {
! 705: if (tmp_hw->hwcard != hwcard)
! 706: continue;
! 707:
! 708: if (tmp_hw->cpu_no == cpu_no)
! 709: break;
! 710: }
! 711:
! 712: if (tmp_hw == NULL) {
! 713: log(LOG_INFO,
! 714: "Error: Failed to find device (slot=%d,bus=%d,cpu=%c)\n",
! 715: hwcard->slot_no, hwcard->bus_no, SDLA_GET_CPU(cpu_no));
! 716: return (EFAULT);
! 717: }
! 718: if (tmp_hw->used) {
! 719: log(LOG_INFO,
! 720: "Error: Device is still in used (slot=%d,bus=%d,cpu=%c,%d)\n",
! 721: hwcard->slot_no,
! 722: hwcard->bus_no,
! 723: SDLA_GET_CPU(cpu_no),
! 724: hwcard->used);
! 725: return (EBUSY);
! 726: }
! 727:
! 728: tmp_hw->hwprobe = NULL;
! 729: tmp_hw->hwcard = NULL;
! 730: hwcard->used--; /* Decrement card usage */
! 731: LIST_REMOVE(tmp_hw, next);
! 732: free(tmp_hw, M_DEVBUF);
! 733:
! 734: return (0);
! 735: }
! 736: #endif
! 737:
! 738: static sdlahw_t*
! 739: sdla_hw_search(u_int16_t atype, int slot_no, int bus_no, int cpu_no)
! 740: {
! 741: sdlahw_t* tmp_hw;
! 742:
! 743:
! 744: LIST_FOREACH(tmp_hw, &sdlahw_head, next) {
! 745: if (tmp_hw->hwcard == NULL) {
! 746: log(LOG_INFO,
! 747: "Critical Error: sdla_cpu_search: line %d\n",
! 748: __LINE__);
! 749: // XXX REMOVE in LIST_FOREACH
! 750: LIST_REMOVE(tmp_hw, next);
! 751: continue;
! 752: }
! 753: if (tmp_hw->hwcard->atype != atype) {
! 754: // XXX why ???
! 755: LIST_REMOVE(tmp_hw, next);
! 756: continue;
! 757: }
! 758: if (tmp_hw->hwcard->slot_no == slot_no &&
! 759: tmp_hw->hwcard->bus_no == bus_no &&
! 760: tmp_hw->cpu_no == cpu_no)
! 761: return (tmp_hw);
! 762: }
! 763:
! 764: return (NULL);
! 765: }
! 766:
! 767:
! 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: */
! 775:
! 776: int
! 777: sdla_setup(void *phw)
! 778: {
! 779: sdlahw_card_t* hwcard = NULL;
! 780: sdlahw_t* hw = (sdlahw_t*)phw;
! 781: int err=0;
! 782:
! 783: WAN_ASSERT(hw == NULL);
! 784: SDLA_MAGIC(hw);
! 785: WAN_ASSERT(hw->hwcard == NULL);
! 786: hwcard = hw->hwcard;
! 787: switch (hwcard->type) {
! 788: case SDLA_AFT:
! 789: break;
! 790:
! 791: default:
! 792: log(LOG_INFO, "%s: Invalid card type %x\n",
! 793: hw->devname, hw->hwcard->type);
! 794: return (EINVAL);
! 795: }
! 796:
! 797: hw->dpmsize = SDLA_WINDOWSIZE;
! 798:
! 799: err = sdla_detect(hw);
! 800: return (err);
! 801: }
! 802:
! 803:
! 804: /*
! 805: * Shut down SDLA: disable shared memory access and interrupts, stop CPU, etc.
! 806: */
! 807: int
! 808: sdla_down(void *phw)
! 809: {
! 810: sdlahw_card_t* card = NULL;
! 811: sdlahw_t* hw = (sdlahw_t*)phw;
! 812:
! 813: WAN_ASSERT(hw == NULL);
! 814: SDLA_MAGIC(hw);
! 815: WAN_ASSERT(hw->hwcard == NULL);
! 816: 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) {
! 821: bus_space_unmap(hw->hwcard->memt,
! 822: hw->dpmbase,
! 823: XILINX_PCI_MEM_SIZE);
! 824: hw->status &= ~SDLA_MEM_MAPPED;
! 825: }
! 826: break;
! 827:
! 828: default:
! 829: return (EINVAL);
! 830: }
! 831: return (0);
! 832: }
! 833:
! 834: /*
! 835: * Read the hardware interrupt status.
! 836: */
! 837: int
! 838: sdla_read_int_stat(void *phw, u_int32_t *int_status)
! 839: {
! 840: sdlahw_card_t* card = NULL;
! 841: sdlahw_t* hw = (sdlahw_t*)phw;
! 842:
! 843: WAN_ASSERT(hw == NULL);
! 844: SDLA_MAGIC(hw);
! 845: WAN_ASSERT(hw->hwcard == NULL);
! 846: card = hw->hwcard;
! 847: switch (card->type) {
! 848: case SDLA_AFT:
! 849: sdla_pci_read_config_dword(hw, PCI_INT_STATUS, int_status);
! 850: }
! 851: return (0);
! 852: }
! 853:
! 854:
! 855: /*
! 856: * Generate an interrupt to adapter's CPU.
! 857: */
! 858: int
! 859: sdla_cmd(void *phw, unsigned long offset, wan_mbox_t *mbox)
! 860: {
! 861: sdlahw_t *hw = (sdlahw_t*)phw;
! 862: int len = sizeof(wan_cmd_t);
! 863: int err = 0;
! 864: u_int8_t value;
! 865:
! 866: SDLA_MAGIC(hw);
! 867: len += mbox->wan_data_len;
! 868:
! 869: sdla_peek(hw, offset, (void*)&value, 1);
! 870: if (value != 0x00) {
! 871: log(LOG_INFO, "%s: opp flag set on entry to sdla_exec!\n",
! 872: hw->devname);
! 873: return (0);
! 874: }
! 875: mbox->wan_opp_flag = 0x00;
! 876: sdla_poke(hw, offset, (void*)mbox, len);
! 877:
! 878: err = sdla_exec(hw, offset);
! 879: if (!err) {
! 880: log(LOG_INFO, "%s: Command 0x%02X failed!\n",
! 881: hw->devname, mbox->wan_command);
! 882: return (WAN_CMD_TIMEOUT);
! 883: }
! 884: sdla_peek(hw, offset, (void*)mbox, sizeof(wan_cmd_t));
! 885: if (mbox->wan_data_len) {
! 886: sdla_peek(hw, offset+offsetof(wan_mbox_t, wan_data),
! 887: mbox->wan_data, mbox->wan_data_len);
! 888: }
! 889:
! 890: return (mbox->wan_return_code);
! 891: }
! 892:
! 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
! 900: sdla_exec(sdlahw_t *hw, unsigned long offset)
! 901: {
! 902: volatile unsigned long tstop;
! 903: volatile unsigned long nloops;
! 904: u_int8_t value;
! 905:
! 906: value = 0x01;
! 907: sdla_poke(hw, offset, (void*)&value, 1);
! 908: tstop = ticks + EXEC_TIMEOUT;
! 909:
! 910: sdla_peek(hw, offset, (void*)&value, 1);
! 911: for (nloops = 1; value == 0x01; ++ nloops) {
! 912: DELAY(EXEC_DELAY);
! 913: if (ticks > tstop || nloops > MAX_NLOOPS) {
! 914: 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: }
! 920: sdla_peek(hw, offset, (void*)&value, 1);
! 921: }
! 922:
! 923: return (nloops);
! 924: }
! 925:
! 926:
! 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
! 937: sdla_peek(void *phw, unsigned long addr, void *buf, unsigned len)
! 938: {
! 939: sdlahw_card_t* card = NULL;
! 940: sdlahw_t* hw = (sdlahw_t*)phw;
! 941: int err = 0;
! 942:
! 943: WAN_ASSERT(hw == NULL);
! 944: SDLA_MAGIC(hw);
! 945: WAN_ASSERT(hw->hwcard == NULL);
! 946: card = hw->hwcard;
! 947: if (addr + len > hw->memory) /* verify arguments */
! 948: return (EINVAL);
! 949:
! 950: switch (card->type) {
! 951: case SDLA_AFT:
! 952: sdla_peek_by_4(hw, addr, buf, len);
! 953: break;
! 954:
! 955: default:
! 956: log(LOG_INFO, "%s: Invalid card type 0x%X\n",
! 957: __FUNCTION__,card->type);
! 958: err = (EINVAL);
! 959: break;
! 960: }
! 961: return (err);
! 962: }
! 963:
! 964:
! 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
! 971: 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)) {
! 975: sdla_bus_read_1(hw, offset++, (u_int8_t*)buf);
! 976: ((u_int8_t *)buf)++;
! 977: len--;
! 978: }
! 979:
! 980: /* copy data in 4-byte chunks */
! 981: while (len >= 4) {
! 982: sdla_bus_read_4(hw, offset, (u_int32_t*)buf);
! 983: (u_int8_t*)buf += 4;
! 984: offset += 4;
! 985: len -= 4;
! 986: }
! 987:
! 988: /* byte copy any remaining data */
! 989: while (len) {
! 990: sdla_bus_read_1(hw, offset++, (u_int8_t*)buf);
! 991: ((u_int8_t *)buf)++;
! 992: len--;
! 993: }
! 994: }
! 995:
! 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
! 1006: sdla_poke(void *phw, unsigned long addr, void *buf, unsigned len)
! 1007: {
! 1008: sdlahw_card_t* card = NULL;
! 1009: sdlahw_t* hw = (sdlahw_t*)phw;
! 1010: int err = 0;
! 1011:
! 1012: WAN_ASSERT(hw == NULL);
! 1013: SDLA_MAGIC(hw);
! 1014: WAN_ASSERT(hw->hwcard == NULL);
! 1015: card = hw->hwcard;
! 1016: if (addr + len > hw->memory) { /* verify arguments */
! 1017: return (EINVAL);
! 1018: }
! 1019:
! 1020: switch (card->type) {
! 1021: case SDLA_AFT:
! 1022: sdla_poke_by_4(hw, addr, buf, len);
! 1023: break;
! 1024:
! 1025: default:
! 1026: log(LOG_INFO, "%s: Invalid card type 0x%X\n",
! 1027: __FUNCTION__,card->type);
! 1028: err = (EINVAL);
! 1029: break;
! 1030: }
! 1031: return (err);
! 1032: }
! 1033:
! 1034:
! 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
! 1041: 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)) {
! 1045: sdla_bus_write_1(hw, offset++, *(char *)buf);
! 1046: ((char *)buf) ++;
! 1047: len --;
! 1048: }
! 1049:
! 1050: /* copy data in 4-byte chunks */
! 1051: while (len >= 4) {
! 1052: sdla_bus_write_4(hw, offset, *(unsigned long *)buf);
! 1053: offset += 4;
! 1054: (char*)buf += 4;
! 1055: len -= 4;
! 1056: }
! 1057:
! 1058: /* byte copy any remaining data */
! 1059: while (len) {
! 1060: sdla_bus_write_1(hw, offset++, *(char *)buf);
! 1061: ((char *)buf) ++;
! 1062: len --;
! 1063: }
! 1064: }
! 1065:
! 1066: int
! 1067: sdla_poke_byte(void *phw, unsigned long offset, u_int8_t value)
! 1068: {
! 1069: sdlahw_t *hw = (sdlahw_t*)phw;
! 1070:
! 1071: SDLA_MAGIC(hw);
! 1072: /* Sangoma ISA card sdla_bus_write_1(hw, offset, value); */
! 1073: sdla_poke(hw, offset, (void*)&value, 1);
! 1074: return (0);
! 1075: }
! 1076:
! 1077: int
! 1078: sdla_set_bit(void *phw, unsigned long offset, u_int8_t value)
! 1079: {
! 1080: sdlahw_t *hw = (sdlahw_t*)phw;
! 1081: u_int8_t tmp;
! 1082:
! 1083: SDLA_MAGIC(hw);
! 1084: /* Sangoma ISA card -> sdla_bus_read_1(hw, offset, &tmp); */
! 1085: sdla_peek(hw, offset, (void*)&tmp, 1);
! 1086: tmp |= value;
! 1087: /* Sangoma ISA card -> sdla_bus_write_1(hw, offset, tmp); */
! 1088: sdla_poke(hw, offset, (void*)&tmp, 1);
! 1089: return (0);
! 1090: }
! 1091:
! 1092: int
! 1093: sdla_clear_bit(void *phw, unsigned long offset, u_int8_t value)
! 1094: {
! 1095: sdlahw_t *hw = (sdlahw_t*)phw;
! 1096: u_int8_t tmp;
! 1097:
! 1098: SDLA_MAGIC(hw);
! 1099: /* Sangoma ISA card -> sdla_bus_read_1(hw, offset, &tmp); */
! 1100: sdla_peek(hw, offset, (void*)&tmp, 1);
! 1101: tmp &= ~value;
! 1102: /* Sangoma ISA card -> sdla_bus_write_1(hw, offset, tmp); */
! 1103: sdla_poke(hw, offset, (void*)&tmp, 1);
! 1104: return (0);
! 1105: }
! 1106:
! 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
! 1112: sdla_detect_aft(sdlahw_t *hw)
! 1113: {
! 1114: sdlahw_card_t *card;
! 1115: u_int16_t ut_u16;
! 1116:
! 1117: WAN_ASSERT(hw == NULL);
! 1118: WAN_ASSERT(hw->hwcard == NULL);
! 1119: card = hw->hwcard;
! 1120: sdla_pci_read_config_dword(hw,
! 1121: (hw->cpu_no == SDLA_CPU_A) ? PCI_IO_BASE_DWORD :
! 1122: 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) {
! 1125: printf("%s: No PCI memory allocated for CPU #B\n",
! 1126: hw->devname);
! 1127: } else {
! 1128: printf("%s: No PCI memory allocated to card\n",
! 1129: hw->devname);
! 1130: }
! 1131: return (EINVAL);
! 1132: }
! 1133: #ifdef DEBUG
! 1134: log(LOG_INFO, "%s: AFT PCI memory at 0x%lX\n",
! 1135: hw->devname, (unsigned long)hw->mem_base_addr);
! 1136: #endif /* DEBUG */
! 1137: sdla_pci_read_config_byte(hw, PCI_INTLINE, (u_int8_t*)&hw->irq);
! 1138: if (hw->irq == PCI_IRQ_NOT_ALLOCATED) {
! 1139: printf("%s: IRQ not allocated to AFT adapter\n", hw->devname);
! 1140: return (EINVAL);
! 1141: }
! 1142:
! 1143: #ifdef DEBUG
! 1144: log(LOG_INFO, "%s: IRQ %d allocated to the AFT PCI card\n",
! 1145: hw->devname, hw->irq);
! 1146: #endif /* DEBUG */
! 1147:
! 1148: hw->memory=XILINX_PCI_MEM_SIZE;
! 1149:
! 1150: /* Map the physical PCI memory to virtual memory */
! 1151: bus_space_map(hw->hwcard->memt, hw->mem_base_addr, XILINX_PCI_MEM_SIZE,
! 1152: 0, &hw->dpmbase);
! 1153: if (!hw->dpmbase) {
! 1154: printf("%s: couldn't map memory\n", hw->devname);
! 1155: return (EINVAL);
! 1156: }
! 1157: hw->status |= SDLA_MEM_MAPPED;
! 1158:
! 1159:
! 1160: /* Enable master operation on PCI and enable bar0 memory */
! 1161: sdla_pci_read_config_word(hw, XILINX_PCI_CMD_REG, &ut_u16);
! 1162: ut_u16 |=0x06;
! 1163: sdla_pci_write_config_word(hw, XILINX_PCI_CMD_REG, ut_u16);
! 1164:
! 1165: /* Set PCI Latency of 0xFF*/
! 1166: sdla_pci_write_config_dword(hw, XILINX_PCI_LATENCY_REG,
! 1167: XILINX_PCI_LATENCY);
! 1168:
! 1169: return (0);
! 1170: }
! 1171:
! 1172:
! 1173: /*
! 1174: * Detect adapter type.
! 1175: */
! 1176: static int
! 1177: sdla_detect(sdlahw_t *hw)
! 1178: {
! 1179: sdlahw_card_t *card = NULL;
! 1180: int err = 0;
! 1181:
! 1182: WAN_ASSERT(hw == NULL);
! 1183: WAN_ASSERT(hw->hwcard == NULL);
! 1184: card = hw->hwcard;
! 1185: switch (card->type) {
! 1186: case SDLA_AFT:
! 1187: err = sdla_detect_aft(hw);
! 1188: break;
! 1189: }
! 1190: if (err)
! 1191: sdla_down(hw);
! 1192:
! 1193: return (err);
! 1194: }
! 1195:
! 1196: int
! 1197: sdla_is_te1(void *phw)
! 1198: {
! 1199: sdlahw_card_t *hwcard = NULL;
! 1200: sdlahw_t *hw = (sdlahw_t*)phw;
! 1201:
! 1202: WAN_ASSERT(hw == NULL);
! 1203: SDLA_MAGIC(hw);
! 1204: WAN_ASSERT(hw->hwcard == NULL);
! 1205: 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: }
! 1216:
! 1217: int
! 1218: sdla_check_mismatch(void *phw, unsigned char media)
! 1219: {
! 1220: sdlahw_card_t *hwcard = NULL;
! 1221: sdlahw_t *hw = (sdlahw_t*)phw;
! 1222:
! 1223: WAN_ASSERT(hw == NULL);
! 1224: SDLA_MAGIC(hw);
! 1225: WAN_ASSERT(hw->hwcard == NULL);
! 1226: hwcard = hw->hwcard;
! 1227: if (media == WAN_MEDIA_T1 ||
! 1228: media == WAN_MEDIA_E1) {
! 1229: if (hwcard->atype != S5144_ADPTR_1_CPU_T1E1 &&
! 1230: hwcard->atype != S5147_ADPTR_2_CPU_T1E1 &&
! 1231: hwcard->atype != S5148_ADPTR_1_CPU_T1E1) {
! 1232: log(LOG_INFO, "%s: Error: Card type mismatch: "
! 1233: "User=T1/E1 Actual=%s\n", hw->devname,
! 1234: SDLA_ADPTR_DECODE(hwcard->atype));
! 1235: return (EIO);
! 1236: }
! 1237: hwcard->atype = S5144_ADPTR_1_CPU_T1E1;
! 1238:
! 1239: } else if (media == WAN_MEDIA_56K) {
! 1240: if (hwcard->atype != S5145_ADPTR_1_CPU_56K) {
! 1241: log(LOG_INFO, "%s: Error: Card type mismatch: "
! 1242: "User=56K Actual=%s\n", hw->devname,
! 1243: SDLA_ADPTR_DECODE(hwcard->atype));
! 1244: return (EIO);
! 1245: }
! 1246: } else {
! 1247: if (hwcard->atype == S5145_ADPTR_1_CPU_56K ||
! 1248: hwcard->atype == S5144_ADPTR_1_CPU_T1E1 ||
! 1249: hwcard->atype == S5147_ADPTR_2_CPU_T1E1 ||
! 1250: hwcard->atype == S5148_ADPTR_1_CPU_T1E1) {
! 1251: log(LOG_INFO, "%s: Error: Card type mismatch: "
! 1252: "User=S514(1/2/3) Actual=%s\n", hw->devname,
! 1253: SDLA_ADPTR_DECODE(hwcard->atype));
! 1254: return (EIO);
! 1255: }
! 1256: }
! 1257:
! 1258: return (0);
! 1259: }
! 1260:
! 1261: int
! 1262: sdla_getcfg(void *phw, int type, void *value)
! 1263: {
! 1264: sdlahw_t* hw = (sdlahw_t*)phw;
! 1265: sdlahw_card_t *hwcard;
! 1266:
! 1267: WAN_ASSERT(hw == NULL);
! 1268: SDLA_MAGIC(hw);
! 1269: WAN_ASSERT(hw->hwcard == NULL);
! 1270: 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 +
! 1280: 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: }
! 1315:
! 1316:
! 1317: int
! 1318: sdla_get_hwcard(void *phw, void **phwcard)
! 1319: {
! 1320: sdlahw_t *hw = (sdlahw_t*)phw;
! 1321:
! 1322: WAN_ASSERT(hw == NULL);
! 1323: SDLA_MAGIC(hw);
! 1324:
! 1325: *phwcard = hw->hwcard;
! 1326: return (0);
! 1327: }
! 1328:
! 1329:
! 1330: int
! 1331: sdla_get_hwprobe(void *phw, void **str)
! 1332: {
! 1333: sdlahw_t *hw = (sdlahw_t*)phw;
! 1334:
! 1335: WAN_ASSERT(hw == NULL);
! 1336: SDLA_MAGIC(hw);
! 1337:
! 1338: if (hw->hwprobe)
! 1339: *str = hw->hwprobe->hw_info;
! 1340:
! 1341: return (0);
! 1342: }
! 1343:
! 1344: int
! 1345: sdla_bus_write_1(void *phw, unsigned int offset, u_int8_t value)
! 1346: {
! 1347: sdlahw_t *hw = (sdlahw_t*)phw;
! 1348:
! 1349: WAN_ASSERT(hw == NULL);
! 1350: SDLA_MAGIC(hw);
! 1351: if (!(hw->status & SDLA_MEM_MAPPED))
! 1352: return (0);
! 1353: bus_space_write_1(hw->hwcard->memt, hw->dpmbase, offset, value);
! 1354: return (0);
! 1355: }
! 1356:
! 1357: int
! 1358: sdla_bus_write_2(void *phw, unsigned int offset, u_int16_t value)
! 1359: {
! 1360: sdlahw_t *hw = (sdlahw_t*)phw;
! 1361:
! 1362: WAN_ASSERT(hw == NULL);
! 1363: SDLA_MAGIC(hw);
! 1364: if (!(hw->status & SDLA_MEM_MAPPED))
! 1365: return (0);
! 1366: bus_space_write_2(hw->hwcard->memt, hw->dpmbase, offset, value);
! 1367: return (0);
! 1368: }
! 1369:
! 1370: int
! 1371: sdla_bus_write_4(void *phw, unsigned int offset, u_int32_t value)
! 1372: {
! 1373: sdlahw_t *hw = (sdlahw_t*)phw;
! 1374:
! 1375: WAN_ASSERT(hw == NULL);
! 1376: SDLA_MAGIC(hw);
! 1377: if (!(hw->status & SDLA_MEM_MAPPED))
! 1378: return (0);
! 1379: bus_space_write_4(hw->hwcard->memt, hw->dpmbase, offset, value);
! 1380: return (0);
! 1381: }
! 1382:
! 1383: int
! 1384: sdla_bus_read_1(void *phw, unsigned int offset, u_int8_t *value)
! 1385: {
! 1386: sdlahw_t *hw = (sdlahw_t*)phw;
! 1387:
! 1388: WAN_ASSERT2(hw == NULL, 0);
! 1389: 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: }
! 1395:
! 1396: int
! 1397: sdla_bus_read_2(void *phw, unsigned int offset, u_int16_t *value)
! 1398: {
! 1399: sdlahw_t *hw = (sdlahw_t*)phw;
! 1400:
! 1401: WAN_ASSERT2(hw == NULL, 0);
! 1402: 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: }
! 1408:
! 1409: int
! 1410: sdla_bus_read_4(void *phw, unsigned int offset, u_int32_t *value)
! 1411: {
! 1412: sdlahw_t *hw = (sdlahw_t*)phw;
! 1413:
! 1414: WAN_ASSERT2(hw == NULL, 0);
! 1415: WAN_ASSERT2(hw->dpmbase == 0, 0);
! 1416: 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: }
! 1422:
! 1423: static int
! 1424: sdla_pci_read_config_dword(void *phw, int reg, u_int32_t *value)
! 1425: {
! 1426: sdlahw_t *hw = (sdlahw_t*)phw;
! 1427: sdlahw_card_t *hwcard;
! 1428:
! 1429: WAN_ASSERT(hw == NULL);
! 1430: SDLA_MAGIC(hw);
! 1431: WAN_ASSERT(hw->hwcard == NULL);
! 1432: hwcard = hw->hwcard;
! 1433: *value = pci_conf_read(hwcard->pa.pa_pc, hwcard->pa.pa_tag, reg);
! 1434: return (0);
! 1435: }
! 1436:
! 1437: static int
! 1438: sdla_pci_read_config_word(void *phw, int reg, u_int16_t *value)
! 1439: {
! 1440: sdlahw_t *hw = (sdlahw_t*)phw;
! 1441: sdlahw_card_t *hwcard;
! 1442: u_int32_t tmp = 0x00;
! 1443:
! 1444: WAN_ASSERT(hw == NULL);
! 1445: SDLA_MAGIC(hw);
! 1446: WAN_ASSERT(hw->hwcard == NULL);
! 1447: hwcard = hw->hwcard;
! 1448: 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: }
! 1452:
! 1453: static int
! 1454: sdla_pci_read_config_byte(void *phw, int reg, u_int8_t *value)
! 1455: {
! 1456: sdlahw_t *hw = (sdlahw_t*)phw;
! 1457: sdlahw_card_t *hwcard;
! 1458: u_int32_t tmp = 0x00;
! 1459:
! 1460: WAN_ASSERT(hw == NULL);
! 1461: SDLA_MAGIC(hw);
! 1462: WAN_ASSERT(hw->hwcard == NULL);
! 1463: hwcard = hw->hwcard;
! 1464: tmp = pci_conf_read(hwcard->pa.pa_pc, hwcard->pa.pa_tag, reg);
! 1465: *value = (u_int8_t)(tmp & 0xFF);
! 1466: return (0);
! 1467: }
! 1468:
! 1469: static int
! 1470: sdla_pci_write_config_dword(void *phw, int reg, u_int32_t value)
! 1471: {
! 1472: sdlahw_t *hw = (sdlahw_t*)phw;
! 1473: sdlahw_card_t *card;
! 1474:
! 1475: WAN_ASSERT(hw == NULL);
! 1476: SDLA_MAGIC(hw);
! 1477: WAN_ASSERT(hw->hwcard == NULL);
! 1478: card = hw->hwcard;
! 1479: pci_conf_write(card->pa.pa_pc, card->pa.pa_tag, reg, value);
! 1480: return (0);
! 1481: }
! 1482:
! 1483: static int
! 1484: sdla_pci_write_config_word(void *phw, int reg, u_int16_t value)
! 1485: {
! 1486: sdlahw_t *hw = (sdlahw_t*)phw;
! 1487: sdlahw_card_t *card;
! 1488:
! 1489: WAN_ASSERT(hw == NULL);
! 1490: SDLA_MAGIC(hw);
! 1491: WAN_ASSERT(hw->hwcard == NULL);
! 1492: card = hw->hwcard;
! 1493: pci_conf_write(card->pa.pa_pc, card->pa.pa_tag, reg, value);
! 1494: return (0);
! 1495: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_sandrv.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci