root/dev/cardbus/com_cardbus.c

DEFINITIONS

1. com_cardbus_find_csdev
2. com_cardbus_match
3. com_cardbus_gofigure
4. com_cardbus_attach
5. com_cardbus_setup
6. com_cardbus_enable
7. com_cardbus_disable
8. com_cardbus_detach

    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 $ */
    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  */
   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.  */
   49 #include <sys/param.h>
   50 #include <sys/systm.h>
   51 #include <sys/tty.h>
   52 #include <sys/device.h>
   54 #include <dev/cardbus/cardbusvar.h>
   55 #include <dev/pci/pcidevs.h>
   57 #include <dev/pcmcia/pcmciareg.h>
   59 #include "com.h"
   60 #ifdef i386
   61 #include "pccom.h"
   62 #endif
   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>
   73 #define com_lcr         com_cfcr
   75 struct com_cardbus_softc {
   76         struct com_softc        cc_com;
   77         void                    *cc_ih;
cardbus_devfunc_t       cc_ct;
bus_addr_t              cc_addr;
cardbusreg_t            cc_base;
bus_size_t              cc_size;
cardbusreg_t            cc_csr;
   83         int                     cc_cben;
cardbustag_t            cc_tag;
cardbusreg_t            cc_reg;
   86         int                     cc_type;
u_char                  cc_bug;
   88 };
   90 #define DEVNAME(CSC) ((CSC)->cc_com.sc_dev.dv_xname)
   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);
   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 *);
  103 #if NCOM_CARDBUS
  104 struct cfattach com_cardbus_ca = {
  105         sizeof(struct com_cardbus_softc), com_cardbus_match,
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,
com_cardbus_attach, com_cardbus_detach, com_activate
  112 };
  113 #endif
  115 #define BUG_BROADCOM    0x01
  117 static struct csdev {
u_short         vendor;
u_short         product;
cardbusreg_t    reg;
u_char          type;
u_char          bug;
  123 } csdevs[] = {
  124         { PCI_VENDOR_3COM, PCI_PRODUCT_3COM_GLOBALMODEM56,
CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO },
  126         { PCI_VENDOR_3COM, PCI_PRODUCT_3COM_MODEM56,
CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO },
  128         { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_BCM4322,
CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO, BUG_BROADCOM },
  130         { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_SERIAL,
CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO, BUG_BROADCOM },
  132         { PCI_VENDOR_BROADCOM, PCI_PRODUCT_BROADCOM_SERIAL_GC,
CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO },
  134         { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_MODEM56,
CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO },
  136         { PCI_VENDOR_OXFORD2, PCI_PRODUCT_OXFORD2_OXCB950,
CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO },
  138         { PCI_VENDOR_XIRCOM, PCI_PRODUCT_XIRCOM_CBEM56G,
CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO },
  140         { PCI_VENDOR_XIRCOM, PCI_PRODUCT_XIRCOM_MODEM56,
CARDBUS_BASE0_REG, CARDBUS_MAPREG_TYPE_IO }
  142 };
  144 static const int ncsdevs = sizeof(csdevs) / sizeof(csdevs[0]);
  146 struct csdev*
com_cardbus_find_csdev(struct cardbus_attach_args *ca)
  148 {
  149         struct csdev *cp;
  151         for (cp = csdevs; cp < csdevs + ncsdevs; cp++)
  152                 if (cp->vendor == CARDBUS_VENDOR(ca->ca_id) &&
cp->product == CARDBUS_PRODUCT(ca->ca_id))
  154                         return (cp);
  155         return (NULL);
  156 }
  158 int
com_cardbus_match(struct device *parent, void *match, void *aux)
  160 {
  161         struct cardbus_attach_args *ca = aux;
  163         /* known devices are ok */
  164         if (com_cardbus_find_csdev(ca) != NULL)
  165             return (10);
  167         /* as are serial devices with a known UART */
  168         if (ca->ca_cis.funcid == PCMCIA_FUNCTION_SERIAL &&
ca->ca_cis.funce.serial.uart_present != 0 &&
  170             (ca->ca_cis.funce.serial.uart_type == 0 ||  /* 8250 */
ca->ca_cis.funce.serial.uart_type == 1 ||   /* 16450 */
ca->ca_cis.funce.serial.uart_type == 2))    /* 16550 */
  173                 return (1);
  175         return (0);
  176 }
  178 int
com_cardbus_gofigure(struct cardbus_attach_args *ca,
  180     struct com_cardbus_softc *csc)
  181 {
  182         int i, index = -1;
cardbusreg_t cis_ptr;
  184         struct csdev *cp;
  186         /* If this device is listed above, use the known values, */
cp = com_cardbus_find_csdev(ca);
  188         if (cp != NULL) {
csc->cc_reg = cp->reg;
csc->cc_type = cp->type;
csc->cc_bug = cp->bug;
  192                 return (0);
  193         }
cis_ptr = Cardbus_conf_read(csc->cc_ct, csc->cc_tag, CARDBUS_CIS_REG);
  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) ==
CARDBUS_CIS_ASI_BAR(ca->ca_cis.bar[i].flags))
  207                         continue;
  208                 if (index != -1)
  209                         goto multi_bar;
index = i;
  211         }
  212         if (index == -1) {
printf(": couldn't find any base address tuple\n");
  214                 return (1);
  215         }
csc->cc_reg = CARDBUS_CIS_ASI_BAR(ca->ca_cis.bar[index].flags);
  217         if ((ca->ca_cis.bar[index].flags & 0x10) == 0)
csc->cc_type = CARDBUS_MAPREG_TYPE_MEM;
  219         else
csc->cc_type = CARDBUS_MAPREG_TYPE_IO;
  221         return (0);
multi_bar:
printf(": there are more than one possible base\n");
printf("%s: address for this device, "
  227             "please report the following information\n",
DEVNAME(csc));
printf("%s: vendor 0x%x product 0x%x\n", DEVNAME(csc),
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) ==
CARDBUS_CIS_ASI_BAR(ca->ca_cis.bar[i].flags))
  238                         continue;
printf("%s: base address %x type %s size %x\n",
DEVNAME(csc), CARDBUS_CIS_ASI_BAR(ca->ca_cis.bar[i].flags),
  241                     (ca->ca_cis.bar[i].flags & 0x10) ? "i/o" : "mem",
ca->ca_cis.bar[i].size);
  243         }
  244         return (1);
  245 }
  247 void
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;
csc->cc_ct = ca->ca_ct;
csc->cc_tag = Cardbus_make_tag(csc->cc_ct);
  257         if (com_cardbus_gofigure(ca, csc) != 0)
  258                 return;
  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) {
printf("failed to map memory");
  263                 return;
  264         }
csc->cc_base = csc->cc_addr;
csc->cc_csr = CARDBUS_COMMAND_MASTER_ENABLE;
  268         if (csc->cc_type == CARDBUS_MAPREG_TYPE_IO) {
csc->cc_base |= CARDBUS_MAPREG_TYPE_IO;
csc->cc_csr |= CARDBUS_COMMAND_IO_ENABLE;
csc->cc_cben = CARDBUS_IO_ENABLE;
  272         } else {
csc->cc_csr |= CARDBUS_COMMAND_MEM_ENABLE;
csc->cc_cben = CARDBUS_MEM_ENABLE;
  275         }
sc->sc_iobase = csc->cc_addr;
sc->sc_frequency = COM_FREQ;
sc->enable = com_cardbus_enable;
sc->disable = com_cardbus_disable;
sc->enabled = 0;
  284         if (ca->ca_cis.cis1_info[0] && ca->ca_cis.cis1_info[1]) {
printf(": %s %s\n", ca->ca_cis.cis1_info[0],
ca->ca_cis.cis1_info[1]);
printf("%s", DEVNAME(csc));
  288         }
  290         if (com_cardbus_enable(sc))
printf(": function enable failed\n");
sc->enabled = 1;
sc->sc_hwflags = 0;
sc->sc_swflags = 0;
  297         if (csc->cc_bug & BUG_BROADCOM)
sc->sc_fifolen = 15;
com_attach_subr(sc);
  301 }
  303 void
com_cardbus_setup(struct com_cardbus_softc *csc)
  305 {
cardbus_devfunc_t ct = csc->cc_ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
cardbus_function_tag_t cf = ct->ct_cf;
cardbusreg_t reg;
cardbus_conf_write(cc, cf, csc->cc_tag, csc->cc_reg, csc->cc_base);
  313         /* enable accesses on cardbus bridge */
cf->cardbus_ctrl(cc, csc->cc_cben);
cf->cardbus_ctrl(cc, CARDBUS_BM_ENABLE);
  317         /* and the card itself */
reg = cardbus_conf_read(cc, cf, csc->cc_tag, CARDBUS_COMMAND_STATUS_REG);
reg &= ~(CARDBUS_COMMAND_IO_ENABLE | CARDBUS_COMMAND_MEM_ENABLE);
reg |= csc->cc_csr;
cardbus_conf_write(cc, cf, csc->cc_tag, CARDBUS_COMMAND_STATUS_REG, reg);
  323         /*
  324          * Make sure the latency timer is set to some reasonable
  325          * value.
  326          */
reg = cardbus_conf_read(cc, cf, csc->cc_tag, CARDBUS_BHLC_REG);
  328         if (CARDBUS_LATTIMER(reg) < 0x20) {
reg &= ~(CARDBUS_LATTIMER_MASK << CARDBUS_LATTIMER_SHIFT);
reg |= (0x20 << CARDBUS_LATTIMER_SHIFT);
cardbus_conf_write(cc, cf, csc->cc_tag, CARDBUS_BHLC_REG, reg);
  332         }
  333 }
  335 int
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;
cardbus_chipset_tag_t cc = psc->sc_cc;
cardbus_function_tag_t cf = psc->sc_cf;
Cardbus_function_enable(csc->cc_ct);
com_cardbus_setup(csc);
  348         /* establish the interrupt. */
csc->cc_ih = cardbus_intr_establish(cc, cf, psc->sc_intrline,
IPL_TTY, comintr, sc, DEVNAME(csc));
  351         if (csc->cc_ih == NULL) {
printf("%s: couldn't establish interrupt\n", DEVNAME(csc));
  353                 return (1);
  354         }
printf(": irq %d", psc->sc_intrline);
  358         return (0);
  359 }
  361 void
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;
cardbus_chipset_tag_t cc = psc->sc_cc;
cardbus_function_tag_t cf = psc->sc_cf;
cardbus_intr_disestablish(cc, cf, csc->cc_ih);
Cardbus_function_disable(csc->cc_ct);
  372 }
  374 int
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;
  382         if ((error = com_detach(self, flags)) != 0)
  383                 return (error);
cardbus_intr_disestablish(psc->sc_cc, psc->sc_cf, csc->cc_ih);
Cardbus_mapreg_unmap(csc->cc_ct, csc->cc_reg, sc->sc_iot, sc->sc_ioh,
csc->cc_size);
  390         return (0);
  391 }