sys/dev/netif/xe/if_xe_pccard.c

   1 /*
   2  * Copyright (c) 2002 Takeshi Shibagaki
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * xe pccard interface driver
  27  *
  28  * $FreeBSD: src/sys/dev/xe/if_xe_pccard.c,v 1.1 2002/02/20 14:23:58 shiba Exp $
  29  * $DragonFly: src/sys/dev/netif/xe/if_xe_pccard.c,v 1.1 2005/07/13 17:31:05 joerg Exp $
  30  */
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/kernel.h>
  35 #include <sys/socket.h>
  36
  37 #include <sys/module.h>
  38 #include <sys/bus.h>
  39
  40 #include <machine/bus.h>
  41 #include <machine/resource.h>
  42 #include <sys/rman.h>
  43
  44 #include <net/ethernet.h>
  45 #include <net/if.h>
  46 #include <net/if_arp.h>
  47 #include <net/if_media.h>
  48 #include <net/if_mib.h>
  49
  50 #include <bus/pccard/pccardvar.h>
  51 #include <bus/pccard/pccarddevs.h>
  52 #include "card_if.h"
  53
  54 #include "if_xereg.h"
  55 #include "if_xevar.h"
  56
  57 static const struct pccard_product xe_pccard_products[] = {
  58         PCMCIA_CARD(ACCTON, EN2226, 0),
  59         PCMCIA_CARD(COMPAQ2, CPQ_10_100, 0),
  60         PCMCIA_CARD(INTEL, EEPRO100, 0),
  61         PCMCIA_CARD(XIRCOM, CE, 0),
  62         PCMCIA_CARD(XIRCOM, CE2, 0),
  63         PCMCIA_CARD(XIRCOM, CE3, 0),
  64         PCMCIA_CARD(XIRCOM, CEM, 0),
  65         PCMCIA_CARD(XIRCOM, CEM28, 0),
  66         PCMCIA_CARD(XIRCOM, CEM33, 0),
  67         PCMCIA_CARD(XIRCOM, CEM56, 0),
  68         PCMCIA_CARD(XIRCOM, REM56, 0),
  69         PCMCIA_CARD(XIRCOM, CNW_801, 0),
  70         PCMCIA_CARD(XIRCOM, CNW_802, 0),
  71         { NULL }
  72 };
  73
  74 struct xe_vendor {
  75         uint32_t         vendor_id;
  76         const char      *vendor_desc;
  77 } xe_vendors[] = {
  78         { PCMCIA_VENDOR_XIRCOM,         "Xircom" },
  79         { PCMCIA_VENDOR_COMPAQ,         "Compaq" },
  80         { PCMCIA_VENDOR_COMPAQ2,        "Compaq" },
  81         { PCMCIA_VENDOR_INTEL,          "Intel" },
  82         { 0,                            "Unknown" }
  83 };
  84
  85 #define XE_CARD_TYPE_FLAGS_NO           0x0
  86 #define XE_CARD_TYPE_FLAGS_CE2          0x1
  87 #define XE_CARD_TYPE_FLAGS_MOHAWK       0x2
  88 #define XE_CARD_TYPE_FLAGS_DINGO        0x4
  89
  90 #define XE_PROD_UMASK           0x100f
  91 #define XE_PROD_MODEM_UMASK     0x1000
  92 #define XE_PROD_SINGLE_ID1      0x1
  93 #define XE_PROD_SINGLE_ID2      0x2
  94 #define XE_PROD_SINGLE_ID3      0x3
  95 #define XE_PROD_MULTI_ID1       0x1001
  96 #define XE_PROD_MULTI_ID2       0x1002
  97 #define XE_PROD_MULTI_ID3       0x1003
  98 #define XE_PROD_MULTI_ID4       0x1004
  99 #define XE_PROD_MULTI_ID5       0x1005
 100 #define XE_PROD_MULTI_ID6       0x1006
 101 #define XE_PROD_MULTI_ID7       0x1007
 102
 103 struct xe_card_type {
 104         uint32_t         prod_type;
 105         const char      *card_type_desc;
 106         uint32_t         flags;
 107 } xe_card_types[] = {
 108         { XE_PROD_MULTI_ID1,    "CEM",          XE_CARD_TYPE_FLAGS_NO },
 109         { XE_PROD_MULTI_ID2,    "CEM2",         XE_CARD_TYPE_FLAGS_CE2 },
 110         { XE_PROD_MULTI_ID3,    "CEM3",         XE_CARD_TYPE_FLAGS_CE2 },
 111         { XE_PROD_MULTI_ID4,    "CEM33",        XE_CARD_TYPE_FLAGS_CE2 },
 112         { XE_PROD_MULTI_ID5,    "CEM56M",       XE_CARD_TYPE_FLAGS_MOHAWK },
 113         { XE_PROD_MULTI_ID6,    "CEM56",        XE_CARD_TYPE_FLAGS_MOHAWK |
 114                                                 XE_CARD_TYPE_FLAGS_DINGO },
 115         { XE_PROD_MULTI_ID7,    "CEM56",        XE_CARD_TYPE_FLAGS_MOHAWK |
 116                                                 XE_CARD_TYPE_FLAGS_DINGO },
 117         { XE_PROD_SINGLE_ID1,   "CE",           XE_CARD_TYPE_FLAGS_NO },
 118         { XE_PROD_SINGLE_ID2,   "CE2",          XE_CARD_TYPE_FLAGS_CE2 },
 119         { XE_PROD_SINGLE_ID3,   "CE3",          XE_CARD_TYPE_FLAGS_MOHAWK },
 120         { 0, NULL, -1 }
 121 };
 122
 123 static struct xe_vendor         *xe_vendor_lookup       (uint32_t);
 124 static struct xe_card_type      *xe_card_type_lookup    (uint32_t);
 125
 126 static int      xe_cem56fix     (device_t);
 127 static int      xe_pccard_probe (device_t);
 128 static int      xe_pccard_match (device_t);
 129 static int      xe_pccard_attach(device_t);
 130
 131 static device_method_t xe_pccard_methods[] = {
 132         /* Device interface */
 133         DEVMETHOD(device_probe,         pccard_compat_probe),
 134         DEVMETHOD(device_attach,        pccard_compat_attach),
 135         DEVMETHOD(device_detach,        xe_detach),
 136
 137         /* Card interface */
 138         DEVMETHOD(card_compat_match,    xe_pccard_match),
 139         DEVMETHOD(card_compat_probe,    xe_pccard_probe),
 140         DEVMETHOD(card_compat_attach,   xe_pccard_attach),
 141
 142         { 0, 0 }
 143 };
 144
 145 static driver_t xe_pccard_driver = {
 146         "xe",
 147         xe_pccard_methods,
 148         sizeof(struct xe_softc),
 149 };
 150
 151 devclass_t xe_devclass;
 152 DRIVER_MODULE(xe, pccard, xe_pccard_driver, xe_devclass, 0, 0);
 153
 154 /*
 155  * Fixing for RealPort cards - they need a little furtling to get the
 156  * ethernet working. But this codes don't work well in NEWCARD.
 157  */
 158 static int
 159 xe_cem56fix(device_t dev)
 160 {
 161         struct xe_softc *sc = device_get_softc(dev);
 162         bus_space_tag_t bst;
 163         bus_space_handle_t bsh;
 164         struct resource *r;
 165         int rid;
 166         int ioport;
 167
 168         device_printf(dev, "Realport port 0x%0lx, size 0x%0lx\n",
 169             bus_get_resource_start(dev, SYS_RES_IOPORT, sc->port_rid),
 170             bus_get_resource_count(dev, SYS_RES_IOPORT, sc->port_rid));
 171
 172         rid = 0;
 173         r = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid, 0,
 174                                ~0, 4 << 10, RF_ACTIVE);
 175         if (r == NULL) {
 176                 device_printf(dev, "Can't map in attribute memory\n");
 177                 return -1;
 178         }
 179
 180         bsh = rman_get_bushandle(r);
 181         bst = rman_get_bustag(r);
 182
 183         CARD_SET_RES_FLAGS(device_get_parent(dev), dev, SYS_RES_MEMORY, rid,
 184                            PCCARD_A_MEM_ATTR);
 185
 186         bus_space_write_1(bst, bsh, DINGO_ECOR, DINGO_ECOR_IRQ_LEVEL |
 187                                                 DINGO_ECOR_INT_ENABLE |
 188                                                 DINGO_ECOR_IOB_ENABLE |
 189                                                 DINGO_ECOR_ETH_ENABLE);
 190         ioport = bus_get_resource_start(dev, SYS_RES_IOPORT, sc->port_rid);
 191         bus_space_write_1(bst, bsh, DINGO_EBAR0, ioport & 0xff);
 192         bus_space_write_1(bst, bsh, DINGO_EBAR1, (ioport >> 8) & 0xff);
 193
 194         bus_space_write_1(bst, bsh, DINGO_DCOR0, DINGO_DCOR0_SF_INT);
 195         bus_space_write_1(bst, bsh, DINGO_DCOR1, DINGO_DCOR1_INT_LEVEL |
 196                                                  DINGO_DCOR1_EEDIO);
 197         bus_space_write_1(bst, bsh, DINGO_DCOR2, 0x00);
 198         bus_space_write_1(bst, bsh, DINGO_DCOR3, 0x00);
 199         bus_space_write_1(bst, bsh, DINGO_DCOR4, 0x00);
 200
 201         bus_release_resource(dev, SYS_RES_MEMORY, rid, r);
 202
 203         /* success! */
 204         return 0;
 205 }
 206
 207 static struct xe_vendor *
 208 xe_vendor_lookup(uint32_t vendor_id)
 209 {
 210         struct xe_vendor *v;
 211
 212         for (v = xe_vendors; v->vendor_id != 0; ++v) {
 213                 if(v->vendor_id == vendor_id)
 214                         break;
 215         }
 216         return v;
 217 }
 218
 219 static struct xe_card_type *
 220 xe_card_type_lookup(uint32_t prod)
 221 {
 222         struct xe_card_type *ct;
 223
 224         for (ct = xe_card_types; ct->card_type_desc != NULL; ++ct) {
 225                 if(ct->prod_type == (prod & XE_PROD_UMASK))
 226                         return ct;
 227         }
 228         return NULL;
 229 }
 230
 231 /*
 232  * PCMCIA probe routine.
 233  * Identify the device.  Called from the bus driver when the card is
 234  * inserted or otherwise powers up.
 235  */
 236 static int
 237 xe_pccard_probe(device_t dev)
 238 {
 239         struct xe_softc *scp = device_get_softc(dev);
 240         uint32_t vendor, product, prod;
 241         uint16_t prodext;
 242         uint8_t *ether_addr;
 243         const char *cis3_str=NULL;
 244         struct xe_vendor *vendor_itm;
 245         struct xe_card_type *card_itm;
 246         int i;
 247
 248         /*
 249          * PCCARD_CISTPL_MANFID = 0x20
 250          */
 251         vendor = pccard_get_vendor(dev);
 252         vendor_itm = xe_vendor_lookup(vendor);
 253         /*
 254          * We always have some vendor here, although
 255          * vendor description may be "Unknown".
 256          */
 257         scp->vendor = vendor_itm->vendor_desc;
 258
 259         product = pccard_get_product(dev);
 260         prodext = pccard_get_prodext(dev);
 261
 262         /*
 263          * prod(new) =  rev, media, prod(old)
 264          * prod(new) =  (don't care), (care 0x10 bit), (care 0x0f bit)
 265          */
 266         prod = (product << 8) | prodext;
 267         card_itm = xe_card_type_lookup(prod);
 268         if (card_itm == NULL)
 269                 return ENODEV;
 270
 271         scp->card_type = card_itm->card_type_desc;
 272         if (card_itm->prod_type & XE_PROD_MODEM_UMASK)
 273                 scp->modem = 1;
 274
 275         for (i = 1; i != XE_CARD_TYPE_FLAGS_DINGO; i = i << 1) {
 276                 switch(i & card_itm->flags) {
 277                 case XE_CARD_TYPE_FLAGS_CE2:
 278                         scp->ce2 = 1;
 279                         break;
 280                 case XE_CARD_TYPE_FLAGS_MOHAWK:
 281                         scp->mohawk = 1;
 282                         break;
 283                 case XE_CARD_TYPE_FLAGS_DINGO:
 284                         scp->dingo = 1;
 285                         break;
 286                 }
 287         }
 288
 289         /*
 290          * PCCARD_CISTPL_VERS_1 = 0x15
 291          *
 292          * Check for certain strange CE2's that look like CE's:
 293          * match 3rd version string against "CE2"
 294          */
 295         cis3_str = pccard_get_cis3_str(dev);
 296         if (strcmp(scp->card_type, "CE") == 0)
 297                 if (strcmp(cis3_str, "CE2") ==0)
 298                         scp->card_type = "CE2";
 299
 300         /*
 301          * PCCARD_CISTPL_FUNCE = 0x22
 302          */
 303         ether_addr = pccard_get_ether(dev);
 304         bcopy(ether_addr, scp->arpcom.ac_enaddr, ETHER_ADDR_LEN);
 305
 306         /* Reject unsupported cards */
 307         if (strcmp(scp->card_type, "CE") == 0 ||
 308             strcmp(scp->card_type, "CEM") == 0) {
 309                 device_printf(dev, "Sorry, your %s card is not supported :(\n",
 310                               scp->card_type);
 311                 return ENODEV;
 312         }
 313
 314         /* Success */
 315         return 0;
 316 }
 317
 318 static int
 319 xe_pccard_attach(device_t dev)
 320 {
 321         struct xe_softc *scp = device_get_softc(dev);
 322         int err;
 323
 324         if ((err = xe_activate(dev)) != 0)
 325                 return err;
 326
 327         /* Hack RealPorts into submission */
 328         if (scp->dingo && xe_cem56fix(dev) < 0) {
 329                 device_printf(dev, "Unable to fix your RealPort\n");
 330                 xe_deactivate(dev);
 331                 return ENODEV;
 332         }
 333         return xe_attach(dev);
 334 }
 335
 336 static int
 337 xe_pccard_match(device_t dev)
 338 {
 339         const struct pccard_product *pp;
 340
 341         if ((pp = pccard_product_lookup(dev, xe_pccard_products,
 342              sizeof(xe_pccard_products[0]), NULL)) != NULL) {
 343                 if (pp->pp_name != NULL)
 344                         device_set_desc(dev, pp->pp_name);
 345                 return 0;
 346         }
 347         return EIO;
 348 }