Annotation of sys/dev/cardbus/com_cardbus.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: com_cardbus.c,v 1.30 2007/05/08 21:28:11 deraadt Exp $ */
! 2: /* $NetBSD: com_cardbus.c,v 1.4 2000/04/17 09:21:59 joda Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 2000 Johan Danielsson
! 6: * All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: *
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: *
! 15: * 2. Redistributions in binary form must reproduce the above copyright
! 16: * notice, this list of conditions and the following disclaimer in the
! 17: * documentation and/or other materials provided with the distribution.
! 18: *
! 19: * 3. Neither the name of author nor the names of any contributors may
! 20: * be used to endorse or promote products derived from this
! 21: * software without specific prior written permission.
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 26: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
! 27: * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
! 28: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
! 29: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
! 30: * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
! 31: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
! 32: * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
! 33: * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 34: */
! 35:
! 36: /* This is a driver for CardBus based serial devices. It is less
! 37: generic than it could be, but it keeps the complexity down. So far
! 38: it assumes that anything that reports itself as a `serial' device
! 39: is infact a 16x50 or 8250, which is not necessarily true (in
! 40: practice this shouldn't be a problem). It also does not handle
! 41: devices in the `multiport serial' or `modem' sub-classes, I've
! 42: never seen any of these, so I don't know what they might look like.
! 43:
! 44: If the CardBus device only has one BAR (that is not also the CIS
! 45: BAR) listed in the CIS, it is assumed to be the one to use. For
! 46: devices with more than one BAR, the list of known devies has to be
! 47: updated below. */
! 48:
! 49: #include <sys/param.h>
! 50: #include <sys/systm.h>
! 51: #include <sys/tty.h>
! 52: #include <sys/device.h>
! 53:
! 54: #include <dev/cardbus/cardbusvar.h>
! 55: #include <dev/pci/pcidevs.h>
! 56:
! 57: #include <dev/pcmcia/pcmciareg.h>
! 58:
! 59: #include "com.h"
! 60: #ifdef i386
! 61: #include "pccom.h"
! 62: #endif
! 63:
! 64: #include <dev/ic/comreg.h>
! 65: #if NPCCOM > 0
! 66: #include <i386/isa/pccomvar.h>
! 67: #endif
! 68: #if NCOM > 0
! 69: #include <dev/ic/comvar.h>
! 70: #endif
! 71: #include <dev/ic/ns16550reg.h>
! 72:
! 73: #define com_lcr com_cfcr
! 74:
! 75: struct com_cardbus_softc {
! 76: struct com_softc cc_com;
! 77: void *cc_ih;
! 78: cardbus_devfunc_t cc_ct;
! 79: bus_addr_t cc_addr;
! 80: cardbusreg_t cc_base;
! 81: bus_size_t cc_size;
! 82: cardbusreg_t cc_csr;
! 83: int cc_cben;
! 84: cardbustag_t cc_tag;
! 85: cardbusreg_t cc_reg;
! 86: int cc_type;
! 87: u_char cc_bug;
! 88: };
! 89:
! 90: #define DEVNAME(CSC) ((CSC)->cc_com.sc_dev.dv_xname)
! 91:
! 92: int com_cardbus_match(struct device *, void *, void *);
! 93: void com_cardbus_attach(struct device *, struct device *, void *);
! 94: int com_cardbus_detach(struct device *, int);
! 95:
! 96: void com_cardbus_setup(struct com_cardbus_softc *);
! 97: int com_cardbus_enable(struct com_softc *);
! 98: void com_cardbus_disable(struct com_softc *);
! 99: struct csdev *com_cardbus_find_csdev(struct cardbus_attach_args *);
! 100: int com_cardbus_gofigure(struct cardbus_attach_args *,
! 101: struct com_cardbus_softc *);
! 102:
! 103: #if NCOM_CARDBUS
! 104: struct cfattach com_cardbus_ca = {
! 105: sizeof(struct com_cardbus_softc), com_cardbus_match,
! 106: com_cardbus_attach, com_cardbus_detach, com_activate
! 107: };
! 108: #elif NPCCOM_CARDBUS
! 109: struct cfattach pccom_cardbus_ca = {
! 110: sizeof(struct com_cardbus_softc), com_cardbus_match,
! 111: com_cardbus_attach, com_cardbus_detach, com_activate
! 112: };
! 113: #endif
! 114:
! 115: #define BUG_BROADCOM 0x01
! 116:
! 117: static struct csdev {
! 118: u_short vendor;
! 119: u_short product;
! 120: cardbusreg_t reg;
! 121: u_char type;
! 122: u_char bug;
! 123: } csdevs[] = {
! 124: { PCI_VENDOR_3COM, PCI_PRODUCT_3COM_GLOBALMODEM56,
! 125: CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO },
! 126: { PCI_VENDOR_3COM, PCI_PRODUCT_3COM_MODEM56,
! 127: CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO },
! 128: { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM4322,
! 129: CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO, BUG_BROADCOM },
! 130: { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_SERIAL,
! 131: CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO, BUG_BROADCOM },
! 132: { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_SERIAL_GC,
! 133: CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO },
! 134: { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_MODEM56,
! 135: CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO },
! 136: { PCI_VENDOR_OXFORD2, PCI_PRODUCT_OXFORD2_OXCB950,
! 137: CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO },
! 138: { PCI_VENDOR_XIRCOM, PCI_PRODUCT_XIRCOM_CBEM56G,
! 139: CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO },
! 140: { PCI_VENDOR_XIRCOM, PCI_PRODUCT_XIRCOM_MODEM56,
! 141: CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO }
! 142: };
! 143:
! 144: static const int ncsdevs = sizeof(csdevs) / sizeof(csdevs[0]);
! 145:
! 146: struct csdev*
! 147: com_cardbus_find_csdev(struct cardbus_attach_args *ca)
! 148: {
! 149: struct csdev *cp;
! 150:
! 151: for (cp = csdevs; cp < csdevs + ncsdevs; cp++)
! 152: if (cp->vendor == CARDBUS_VENDOR(ca->ca_id) &&
! 153: cp->product == CARDBUS_PRODUCT(ca->ca_id))
! 154: return (cp);
! 155: return (NULL);
! 156: }
! 157:
! 158: int
! 159: com_cardbus_match(struct device *parent, void *match, void *aux)
! 160: {
! 161: struct cardbus_attach_args *ca = aux;
! 162:
! 163: /* known devices are ok */
! 164: if (com_cardbus_find_csdev(ca) != NULL)
! 165: return (10);
! 166:
! 167: /* as are serial devices with a known UART */
! 168: if (ca->ca_cis.funcid == PCMCIA_FUNCTION_SERIAL &&
! 169: ca->ca_cis.funce.serial.uart_present != 0 &&
! 170: (ca->ca_cis.funce.serial.uart_type == 0 || /* 8250 */
! 171: ca->ca_cis.funce.serial.uart_type == 1 || /* 16450 */
! 172: ca->ca_cis.funce.serial.uart_type == 2)) /* 16550 */
! 173: return (1);
! 174:
! 175: return (0);
! 176: }
! 177:
! 178: int
! 179: com_cardbus_gofigure(struct cardbus_attach_args *ca,
! 180: struct com_cardbus_softc *csc)
! 181: {
! 182: int i, index = -1;
! 183: cardbusreg_t cis_ptr;
! 184: struct csdev *cp;
! 185:
! 186: /* If this device is listed above, use the known values, */
! 187: cp = com_cardbus_find_csdev(ca);
! 188: if (cp != NULL) {
! 189: csc->cc_reg = cp->reg;
! 190: csc->cc_type = cp->type;
! 191: csc->cc_bug = cp->bug;
! 192: return (0);
! 193: }
! 194:
! 195: cis_ptr = Cardbus_conf_read(csc->cc_ct, csc->cc_tag, CARDBUS_CIS_REG);
! 196:
! 197: /* otherwise try to deduce which BAR and type to use from CIS. If
! 198: there is only one BAR, it must be the one we should use, if
! 199: there are more, we're out of luck. */
! 200: for (i = 0; i < 7; i++) {
! 201: /* ignore zero sized BARs */
! 202: if (ca->ca_cis.bar[i].size == 0)
! 203: continue;
! 204: /* ignore the CIS BAR */
! 205: if (CARDBUS_CIS_ASI_BAR(cis_ptr) ==
! 206: CARDBUS_CIS_ASI_BAR(ca->ca_cis.bar[i].flags))
! 207: continue;
! 208: if (index != -1)
! 209: goto multi_bar;
! 210: index = i;
! 211: }
! 212: if (index == -1) {
! 213: printf(": couldn't find any base address tuple\n");
! 214: return (1);
! 215: }
! 216: csc->cc_reg = CARDBUS_CIS_ASI_BAR(ca->ca_cis.bar[index].flags);
! 217: if ((ca->ca_cis.bar[index].flags & 0x10) == 0)
! 218: csc->cc_type = CARDBUS_MAPREG_TYPE_MEM;
! 219: else
! 220: csc->cc_type = CARDBUS_MAPREG_TYPE_IO;
! 221: return (0);
! 222:
! 223: multi_bar:
! 224: printf(": there are more than one possible base\n");
! 225:
! 226: printf("%s: address for this device, "
! 227: "please report the following information\n",
! 228: DEVNAME(csc));
! 229: printf("%s: vendor 0x%x product 0x%x\n", DEVNAME(csc),
! 230: CARDBUS_VENDOR(ca->ca_id), CARDBUS_PRODUCT(ca->ca_id));
! 231: for (i = 0; i < 7; i++) {
! 232: /* ignore zero sized BARs */
! 233: if (ca->ca_cis.bar[i].size == 0)
! 234: continue;
! 235: /* ignore the CIS BAR */
! 236: if (CARDBUS_CIS_ASI_BAR(cis_ptr) ==
! 237: CARDBUS_CIS_ASI_BAR(ca->ca_cis.bar[i].flags))
! 238: continue;
! 239: printf("%s: base address %x type %s size %x\n",
! 240: DEVNAME(csc), CARDBUS_CIS_ASI_BAR(ca->ca_cis.bar[i].flags),
! 241: (ca->ca_cis.bar[i].flags & 0x10) ? "i/o" : "mem",
! 242: ca->ca_cis.bar[i].size);
! 243: }
! 244: return (1);
! 245: }
! 246:
! 247: void
! 248: com_cardbus_attach(struct device *parent, struct device *self, void *aux)
! 249: {
! 250: struct com_softc *sc = (struct com_softc*)self;
! 251: struct com_cardbus_softc *csc = (struct com_cardbus_softc*)self;
! 252: struct cardbus_attach_args *ca = aux;
! 253:
! 254: csc->cc_ct = ca->ca_ct;
! 255: csc->cc_tag = Cardbus_make_tag(csc->cc_ct);
! 256:
! 257: if (com_cardbus_gofigure(ca, csc) != 0)
! 258: return;
! 259:
! 260: if (Cardbus_mapreg_map(ca->ca_ct, csc->cc_reg, csc->cc_type, 0,
! 261: &sc->sc_iot, &sc->sc_ioh, &csc->cc_addr, &csc->cc_size) != 0) {
! 262: printf("failed to map memory");
! 263: return;
! 264: }
! 265:
! 266: csc->cc_base = csc->cc_addr;
! 267: csc->cc_csr = CARDBUS_COMMAND_MASTER_ENABLE;
! 268: if (csc->cc_type == CARDBUS_MAPREG_TYPE_IO) {
! 269: csc->cc_base |= CARDBUS_MAPREG_TYPE_IO;
! 270: csc->cc_csr |= CARDBUS_COMMAND_IO_ENABLE;
! 271: csc->cc_cben = CARDBUS_IO_ENABLE;
! 272: } else {
! 273: csc->cc_csr |= CARDBUS_COMMAND_MEM_ENABLE;
! 274: csc->cc_cben = CARDBUS_MEM_ENABLE;
! 275: }
! 276:
! 277: sc->sc_iobase = csc->cc_addr;
! 278: sc->sc_frequency = COM_FREQ;
! 279:
! 280: sc->enable = com_cardbus_enable;
! 281: sc->disable = com_cardbus_disable;
! 282: sc->enabled = 0;
! 283:
! 284: if (ca->ca_cis.cis1_info[0] && ca->ca_cis.cis1_info[1]) {
! 285: printf(": %s %s\n", ca->ca_cis.cis1_info[0],
! 286: ca->ca_cis.cis1_info[1]);
! 287: printf("%s", DEVNAME(csc));
! 288: }
! 289:
! 290: if (com_cardbus_enable(sc))
! 291: printf(": function enable failed\n");
! 292: sc->enabled = 1;
! 293:
! 294: sc->sc_hwflags = 0;
! 295: sc->sc_swflags = 0;
! 296:
! 297: if (csc->cc_bug & BUG_BROADCOM)
! 298: sc->sc_fifolen = 15;
! 299:
! 300: com_attach_subr(sc);
! 301: }
! 302:
! 303: void
! 304: com_cardbus_setup(struct com_cardbus_softc *csc)
! 305: {
! 306: cardbus_devfunc_t ct = csc->cc_ct;
! 307: cardbus_chipset_tag_t cc = ct->ct_cc;
! 308: cardbus_function_tag_t cf = ct->ct_cf;
! 309: cardbusreg_t reg;
! 310:
! 311: cardbus_conf_write(cc, cf, csc->cc_tag, csc->cc_reg, csc->cc_base);
! 312:
! 313: /* enable accesses on cardbus bridge */
! 314: cf->cardbus_ctrl(cc, csc->cc_cben);
! 315: cf->cardbus_ctrl(cc, CARDBUS_BM_ENABLE);
! 316:
! 317: /* and the card itself */
! 318: reg = cardbus_conf_read(cc, cf, csc->cc_tag, CARDBUS_COMMAND_STATUS_REG);
! 319: reg &= ~(CARDBUS_COMMAND_IO_ENABLE | CARDBUS_COMMAND_MEM_ENABLE);
! 320: reg |= csc->cc_csr;
! 321: cardbus_conf_write(cc, cf, csc->cc_tag, CARDBUS_COMMAND_STATUS_REG, reg);
! 322:
! 323: /*
! 324: * Make sure the latency timer is set to some reasonable
! 325: * value.
! 326: */
! 327: reg = cardbus_conf_read(cc, cf, csc->cc_tag, CARDBUS_BHLC_REG);
! 328: if (CARDBUS_LATTIMER(reg) < 0x20) {
! 329: reg &= ~(CARDBUS_LATTIMER_MASK << CARDBUS_LATTIMER_SHIFT);
! 330: reg |= (0x20 << CARDBUS_LATTIMER_SHIFT);
! 331: cardbus_conf_write(cc, cf, csc->cc_tag, CARDBUS_BHLC_REG, reg);
! 332: }
! 333: }
! 334:
! 335: int
! 336: com_cardbus_enable(struct com_softc *sc)
! 337: {
! 338: struct com_cardbus_softc *csc = (struct com_cardbus_softc*)sc;
! 339: struct cardbus_softc *psc =
! 340: (struct cardbus_softc *)sc->sc_dev.dv_parent;
! 341: cardbus_chipset_tag_t cc = psc->sc_cc;
! 342: cardbus_function_tag_t cf = psc->sc_cf;
! 343:
! 344: Cardbus_function_enable(csc->cc_ct);
! 345:
! 346: com_cardbus_setup(csc);
! 347:
! 348: /* establish the interrupt. */
! 349: csc->cc_ih = cardbus_intr_establish(cc, cf, psc->sc_intrline,
! 350: IPL_TTY, comintr, sc, DEVNAME(csc));
! 351: if (csc->cc_ih == NULL) {
! 352: printf("%s: couldn't establish interrupt\n", DEVNAME(csc));
! 353: return (1);
! 354: }
! 355:
! 356: printf(": irq %d", psc->sc_intrline);
! 357:
! 358: return (0);
! 359: }
! 360:
! 361: void
! 362: com_cardbus_disable(struct com_softc *sc)
! 363: {
! 364: struct com_cardbus_softc *csc = (struct com_cardbus_softc*)sc;
! 365: struct cardbus_softc *psc =
! 366: (struct cardbus_softc *)sc->sc_dev.dv_parent;
! 367: cardbus_chipset_tag_t cc = psc->sc_cc;
! 368: cardbus_function_tag_t cf = psc->sc_cf;
! 369:
! 370: cardbus_intr_disestablish(cc, cf, csc->cc_ih);
! 371: Cardbus_function_disable(csc->cc_ct);
! 372: }
! 373:
! 374: int
! 375: com_cardbus_detach(struct device *self, int flags)
! 376: {
! 377: struct com_cardbus_softc *csc = (struct com_cardbus_softc *) self;
! 378: struct com_softc *sc = (struct com_softc *) self;
! 379: struct cardbus_softc *psc = (struct cardbus_softc *)self->dv_parent;
! 380: int error;
! 381:
! 382: if ((error = com_detach(self, flags)) != 0)
! 383: return (error);
! 384:
! 385: cardbus_intr_disestablish(psc->sc_cc, psc->sc_cf, csc->cc_ih);
! 386:
! 387: Cardbus_mapreg_unmap(csc->cc_ct, csc->cc_reg, sc->sc_iot, sc->sc_ioh,
! 388: csc->cc_size);
! 389:
! 390: return (0);
! 391: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to com_cardbus.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / cardbus