sys/dev/pcmcia/if_wi_pcmcia.c

   1 /* $NetBSD: if_wi_pcmcia.c,v 1.84 2009/05/12 14:42:18 cegger Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2001, 2004 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Ichiro FUKUHARA (ichiro@ichiro.org), and by Charles M. Hannum.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  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  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * PCMCIA attachment for Lucent & Intersil WaveLAN PCMCIA card
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __KERNEL_RCSID(0, "$NetBSD: if_wi_pcmcia.c,v 1.84 2009/05/12 14:42:18 cegger Exp $");
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/callout.h>
  42 #include <sys/device.h>
  43 #include <sys/proc.h>
  44 #include <sys/socket.h>
  45
  46 #include <net/if.h>
  47 #include <net/if_ether.h>
  48 #include <net/if_media.h>
  49
  50 #include <net80211/ieee80211_netbsd.h>
  51 #include <net80211/ieee80211_var.h>
  52 #include <net80211/ieee80211_radiotap.h>
  53 #include <net80211/ieee80211_rssadapt.h>
  54
  55 #include <sys/cpu.h>
  56 #include <sys/bus.h>
  57 #include <sys/intr.h>
  58
  59 #include <dev/ic/wi_ieee.h>
  60 #include <dev/ic/wireg.h>
  61 #include <dev/ic/wivar.h>
  62
  63 #include <dev/pcmcia/pcmciareg.h>
  64 #include <dev/pcmcia/pcmciavar.h>
  65 #include <dev/pcmcia/pcmciadevs.h>
  66
  67 #ifdef _MODULE
  68 #define WI_PCMCIA_SPECTRUM24T_FW 1
  69 #else
  70 #include <opt_if_wi_pcmcia.h>
  71 #endif
  72
  73 #if WI_PCMCIA_SPECTRUM24T_FW
  74 #include <dev/microcode/wi/spectrum24t_cf.h>
  75 #endif
  76
  77 static int      wi_pcmcia_match(device_t, cfdata_t, void *);
  78 static int      wi_pcmcia_validate_config(struct pcmcia_config_entry *);
  79 static void     wi_pcmcia_attach(device_t, device_t, void *);
  80 static int      wi_pcmcia_detach(device_t, int);
  81 static int      wi_pcmcia_enable(struct wi_softc *);
  82 static void     wi_pcmcia_disable(struct wi_softc *);
  83
  84 #if WI_PCMCIA_SPECTRUM24T_FW
  85 /* support to download firmware for symbol CF card */
  86 static int      wi_pcmcia_load_firm(struct wi_softc *, const void *, int, const void *, int);
  87 static int      wi_pcmcia_write_firm(struct wi_softc *, const void *, int, const void *, int);
  88 static int      wi_pcmcia_set_hcr(struct wi_softc *, int);
  89 #endif
  90
  91 struct wi_pcmcia_softc {
  92         struct wi_softc sc_wi;
  93
  94         int sc_symbol_cf;                       /* Spectrum24t CF card */
  95
  96         struct pcmcia_function *sc_pf;          /* PCMCIA function */
  97         int sc_state;
  98 #define WI_PCMCIA_ATTACHED      3
  99 };
 100
 101 CFATTACH_DECL(wi_pcmcia, sizeof(struct wi_pcmcia_softc),
 102     wi_pcmcia_match, wi_pcmcia_attach, wi_pcmcia_detach, wi_activate);
 103
 104 static const struct pcmcia_product wi_pcmcia_products[] = {
 105         { PCMCIA_VENDOR_INVALID, PCMCIA_PRODUCT_INVALID,
 106           PCMCIA_CIS_SMC_2632W },
 107
 108         { PCMCIA_VENDOR_INVALID, PCMCIA_PRODUCT_INVALID,
 109           PCMCIA_CIS_NANOSPEED_PRISM2 },
 110
 111         { PCMCIA_VENDOR_INVALID, PCMCIA_PRODUCT_INVALID,
 112           PCMCIA_CIS_NEC_CMZ_RT_WP },
 113
 114         { PCMCIA_VENDOR_INVALID, PCMCIA_PRODUCT_INVALID,
 115           PCMCIA_CIS_NTT_ME_WLAN },
 116
 117         { PCMCIA_VENDOR_LUCENT, PCMCIA_PRODUCT_LUCENT_HERMES,
 118           PCMCIA_CIS_INVALID },
 119
 120         { PCMCIA_VENDOR_LUCENT, PCMCIA_PRODUCT_LUCENT_HERMES2,
 121           PCMCIA_CIS_INVALID },
 122
 123         { PCMCIA_VENDOR_3COM, PCMCIA_PRODUCT_3COM_3CRWE737A,
 124           PCMCIA_CIS_3COM_3CRWE737A },
 125
 126         { PCMCIA_VENDOR_ALVARION,
 127           PCMCIA_PRODUCT_ALVARION_BREEZENET,
 128           PCMCIA_CIS_ALVARION_BREEZENET },
 129
 130         { PCMCIA_VENDOR_COREGA, PCMCIA_PRODUCT_COREGA_WIRELESS_LAN_PCC_11,
 131           PCMCIA_CIS_COREGA_WIRELESS_LAN_PCC_11 },
 132
 133         { PCMCIA_VENDOR_COREGA, PCMCIA_PRODUCT_COREGA_WIRELESS_LAN_PCCA_11,
 134           PCMCIA_CIS_COREGA_WIRELESS_LAN_PCCA_11 },
 135
 136         { PCMCIA_VENDOR_COREGA, PCMCIA_PRODUCT_COREGA_WIRELESS_LAN_PCCB_11,
 137           PCMCIA_CIS_COREGA_WIRELESS_LAN_PCCB_11 },
 138
 139         { PCMCIA_VENDOR_COREGA, PCMCIA_PRODUCT_COREGA_WIRELESS_LAN_PCCL_11,
 140           PCMCIA_CIS_COREGA_WIRELESS_LAN_PCCL_11 },
 141
 142         { PCMCIA_VENDOR_COREGA, PCMCIA_PRODUCT_COREGA_WIRELESS_LAN_WLCFL_11,
 143           PCMCIA_CIS_COREGA_WIRELESS_LAN_WLCFL_11 },
 144
 145         { PCMCIA_VENDOR_INTEL, PCMCIA_PRODUCT_INTEL_PRO_WLAN_2011,
 146           PCMCIA_CIS_INTEL_PRO_WLAN_2011 },
 147
 148         { PCMCIA_VENDOR_INTERSIL2, PCMCIA_PRODUCT_INTERSIL2_PRISM2,
 149           PCMCIA_CIS_INTERSIL2_PRISM2 },
 150
 151         { PCMCIA_VENDOR_INTERSIL2, PCMCIA_PRODUCT_GEMTEK_WLAN,
 152           PCMCIA_CIS_GEMTEK_WLAN },
 153
 154         { PCMCIA_VENDOR_SAMSUNG, PCMCIA_PRODUCT_SAMSUNG_SWL_2000N,
 155           PCMCIA_CIS_SAMSUNG_SWL_2000N },
 156
 157         { PCMCIA_VENDOR_ELSA, PCMCIA_PRODUCT_ELSA_XI300_IEEE,
 158           PCMCIA_CIS_ELSA_XI300_IEEE },
 159
 160         { PCMCIA_VENDOR_ELSA, PCMCIA_PRODUCT_ELSA_XI325_IEEE,
 161           PCMCIA_CIS_ELSA_XI325_IEEE },
 162
 163         { PCMCIA_VENDOR_ELSA, PCMCIA_PRODUCT_ELSA_XI800_IEEE,
 164           PCMCIA_CIS_ELSA_XI800_IEEE },
 165
 166         { PCMCIA_VENDOR_ELSA, PCMCIA_PRODUCT_ELSA_SMC2531WB,
 167           PCMCIA_CIS_ELSA_SMC2531WB },
 168
 169         { PCMCIA_VENDOR_COMPAQ, PCMCIA_PRODUCT_COMPAQ_NC5004,
 170           PCMCIA_CIS_COMPAQ_NC5004 },
 171
 172         { PCMCIA_VENDOR_CONTEC, PCMCIA_PRODUCT_CONTEC_FX_DS110_PCC,
 173           PCMCIA_CIS_CONTEC_FX_DS110_PCC },
 174
 175         { PCMCIA_VENDOR_TDK, PCMCIA_PRODUCT_TDK_LAK_CD011WL,
 176           PCMCIA_CIS_TDK_LAK_CD011WL },
 177
 178         { PCMCIA_VENDOR_IODATA2, PCMCIA_PRODUCT_IODATA2_WNB11PCM,
 179           PCMCIA_CIS_IODATA2_WNB11PCM },
 180
 181         { PCMCIA_VENDOR_IODATA2, PCMCIA_PRODUCT_IODATA2_WCF12,
 182           PCMCIA_CIS_IODATA2_WCF12 },
 183
 184         { PCMCIA_VENDOR_BUFFALO, PCMCIA_PRODUCT_BUFFALO_WLI_PCM_S11,
 185           PCMCIA_CIS_BUFFALO_WLI_PCM_S11 },
 186
 187         { PCMCIA_VENDOR_BUFFALO, PCMCIA_PRODUCT_BUFFALO_WLI_CF_S11G,
 188           PCMCIA_CIS_BUFFALO_WLI_CF_S11G },
 189
 190         { PCMCIA_VENDOR_EMTAC, PCMCIA_PRODUCT_EMTAC_WLAN,
 191           PCMCIA_CIS_EMTAC_WLAN },
 192
 193         { PCMCIA_VENDOR_INTERSIL, PCMCIA_PRODUCT_INTERSIL_ISL37100P,
 194           PCMCIA_CIS_INTERSIL_ISL37100P },
 195
 196         { PCMCIA_VENDOR_INTERSIL, PCMCIA_PRODUCT_INTERSIL_ISL37110P,
 197           PCMCIA_CIS_INTERSIL_ISL37110P },
 198
 199         { PCMCIA_VENDOR_INTERSIL, PCMCIA_PRODUCT_INTERSIL_ISL37300P,
 200           PCMCIA_CIS_INTERSIL_ISL37300P },
 201
 202         { PCMCIA_VENDOR_SIMPLETECH, PCMCIA_PRODUCT_SIMPLETECH_SPECTRUM24,
 203           PCMCIA_CIS_SIMPLETECH_SPECTRUM24 },
 204
 205         { PCMCIA_VENDOR_ERICSSON, PCMCIA_PRODUCT_ERICSSON_WIRELESSLAN,
 206           PCMCIA_CIS_ERICSSON_WIRELESSLAN },
 207
 208         { PCMCIA_VENDOR_SYMBOL, PCMCIA_PRODUCT_SYMBOL_LA4100,
 209           PCMCIA_CIS_SYMBOL_LA4100 },
 210
 211         { PCMCIA_VENDOR_LINKSYS2, PCMCIA_PRODUCT_LINKSYS2_IWN,
 212           PCMCIA_CIS_NANOSPEED_PRISM2 },
 213
 214         { PCMCIA_VENDOR_LINKSYS2, PCMCIA_PRODUCT_LINKSYS2_IWN3,
 215           PCMCIA_CIS_LINKSYS2_IWN3 },
 216
 217         { PCMCIA_VENDOR_LINKSYS2, PCMCIA_PRODUCT_LINKSYS2_WCF11,
 218           PCMCIA_CIS_LINKSYS2_WCF11 },
 219
 220         { PCMCIA_VENDOR_MICROSOFT, PCMCIA_PRODUCT_MICROSOFT_MN_520,
 221           PCMCIA_CIS_MICROSOFT_MN_520 },
 222
 223         { PCMCIA_VENDOR_PLANEX, PCMCIA_PRODUCT_PLANEX_GWNS11H,
 224           PCMCIA_CIS_PLANEX_GWNS11H },
 225
 226         { PCMCIA_VENDOR_BAY, PCMCIA_PRODUCT_BAY_EMOBILITY_11B,
 227           PCMCIA_CIS_BAY_EMOBILITY_11B },
 228
 229         { PCMCIA_VENDOR_ACTIONTEC, PCMCIA_PRODUCT_ACTIONTEC_PRISM,
 230           PCMCIA_CIS_ACTIONTEC_PRISM },
 231
 232         { PCMCIA_VENDOR_DLINK_2, PCMCIA_PRODUCT_DLINK_DWL650H,
 233           PCMCIA_CIS_DLINK_DWL650H },
 234
 235         { PCMCIA_VENDOR_FUJITSU, PCMCIA_PRODUCT_FUJITSU_WL110,
 236           PCMCIA_CIS_FUJITSU_WL110 },
 237
 238         { PCMCIA_VENDOR_ARTEM, PCMCIA_PRODUCT_ARTEM_ONAIR,
 239           PCMCIA_CIS_ARTEM_ONAIR },
 240
 241         { PCMCIA_VENDOR_ASUSTEK, PCMCIA_PRODUCT_ASUSTEK_WL_100,
 242           PCMCIA_CIS_ASUSTEK_WL_100 },
 243
 244         { PCMCIA_VENDOR_PROXIM, PCMCIA_PRODUCT_PROXIM_RANGELANDS_8430,
 245           PCMCIA_CIS_PROXIM_RANGELANDS_8430 },
 246
 247         { PCMCIA_VENDOR_SIEMENS, PCMCIA_PRODUCT_SIEMENS_SS1021,
 248           PCMCIA_CIS_SIEMENS_SS1021 },
 249 };
 250 static const size_t wi_pcmcia_nproducts =
 251     sizeof(wi_pcmcia_products) / sizeof(wi_pcmcia_products[0]);
 252
 253 static int
 254 wi_pcmcia_match(device_t parent, cfdata_t match,
 255     void *aux)
 256 {
 257         struct pcmcia_attach_args *pa = aux;
 258
 259         if (pcmcia_product_lookup(pa, wi_pcmcia_products, wi_pcmcia_nproducts,
 260             sizeof(wi_pcmcia_products[0]), NULL))
 261                 return (1);
 262         return (0);
 263 }
 264
 265 static int
 266 wi_pcmcia_enable(struct wi_softc *sc)
 267 {
 268         struct wi_pcmcia_softc *psc = (struct wi_pcmcia_softc *)sc;
 269         struct pcmcia_function *pf = psc->sc_pf;
 270         int error;
 271
 272         /* establish the interrupt. */
 273         sc->sc_ih = pcmcia_intr_establish(pf, IPL_NET, wi_intr, sc);
 274         if (!sc->sc_ih)
 275                 return (EIO);
 276
 277         error = pcmcia_function_enable(pf);
 278         if (error) {
 279                 pcmcia_intr_disestablish(pf, sc->sc_ih);
 280                 sc->sc_ih = 0;
 281                 return (EIO);
 282         }
 283
 284         if (psc->sc_symbol_cf) {
 285 #if WI_PCMCIA_SPECTRUM24T_FW
 286                 if (wi_pcmcia_load_firm(sc,
 287                     spectrum24t_primsym, sizeof(spectrum24t_primsym),
 288                     spectrum24t_secsym, sizeof(spectrum24t_secsym))) {
 289                         aprint_error_dev(&sc->sc_dev, "couldn't load firmware\n");
 290                         wi_pcmcia_disable(sc);
 291                         return (EIO);
 292                 }
 293 #else
 294                 aprint_error_dev(&sc->sc_dev, "firmware load not configured\n");
 295                 return EIO;
 296 #endif
 297         }
 298         DELAY(1000);
 299
 300         return (0);
 301 }
 302
 303 static void
 304 wi_pcmcia_disable(struct wi_softc *sc)
 305 {
 306         struct wi_pcmcia_softc *psc = (struct wi_pcmcia_softc *)sc;
 307
 308         pcmcia_function_disable(psc->sc_pf);
 309         pcmcia_intr_disestablish(psc->sc_pf, sc->sc_ih);
 310         sc->sc_ih = 0;
 311 }
 312
 313 static int
 314 wi_pcmcia_validate_config(struct pcmcia_config_entry *cfe)
 315 {
 316         if (cfe->iftype != PCMCIA_IFTYPE_IO ||
 317             cfe->num_iospace != 1 ||
 318             cfe->iospace[0].length < WI_IOSIZE)
 319                 return (EINVAL);
 320         cfe->num_memspace = 0;
 321         return (0);
 322 }
 323
 324 static void
 325 wi_pcmcia_attach(struct device  *parent, device_t self,
 326     void *aux)
 327 {
 328         struct wi_pcmcia_softc *psc = (void *)self;
 329         struct wi_softc *sc = &psc->sc_wi;
 330         struct pcmcia_attach_args *pa = aux;
 331         struct pcmcia_config_entry *cfe;
 332         int haveaddr;
 333         int error;
 334
 335         aprint_naive("\n");
 336
 337         psc->sc_pf = pa->pf;
 338
 339         error = pcmcia_function_configure(pa->pf, wi_pcmcia_validate_config);
 340         if (error) {
 341                 aprint_error_dev(self, "configure failed, error=%d\n",
 342                     error);
 343                 return;
 344         }
 345
 346         cfe = pa->pf->cfe;
 347         sc->sc_iot = cfe->iospace[0].handle.iot;
 348         sc->sc_ioh = cfe->iospace[0].handle.ioh;
 349
 350         if (pa->manufacturer == PCMCIA_VENDOR_SYMBOL &&
 351             pa->product == PCMCIA_PRODUCT_SYMBOL_LA4100)
 352                 psc->sc_symbol_cf = 1;
 353         /*
 354          * XXX: Sony PEGA-WL100 CF card has a same vendor/product id as
 355          *      Intel PCMCIA card.  It may be incorrect to detect by the
 356          *      initial value of COR register.
 357          */
 358         if (pa->manufacturer == PCMCIA_VENDOR_INTEL &&
 359             pa->product == PCMCIA_PRODUCT_INTEL_PRO_WLAN_2011 &&
 360             CSR_READ_2(sc, WI_COR) == WI_COR_IOMODE)
 361                 psc->sc_symbol_cf = 1;
 362
 363         error = wi_pcmcia_enable(sc);
 364         if (error)
 365                 goto fail;
 366
 367         sc->sc_pci = 0;
 368         sc->sc_enable = wi_pcmcia_enable;
 369         sc->sc_disable = wi_pcmcia_disable;
 370
 371         printf("%s:", device_xname(self));
 372
 373         haveaddr = pa->pf->pf_funce_lan_nidlen == IEEE80211_ADDR_LEN;
 374         if (wi_attach(sc, haveaddr ? pa->pf->pf_funce_lan_nid : 0) != 0) {
 375                 aprint_error_dev(self, "failed to attach controller\n");
 376                 goto fail2;
 377         }
 378
 379         if (pmf_device_register(self, NULL, NULL))
 380                 pmf_class_network_register(self, &sc->sc_if);
 381         else
 382                 aprint_error_dev(self, "couldn't establish power handler\n");
 383
 384         wi_pcmcia_disable(sc);
 385         psc->sc_state = WI_PCMCIA_ATTACHED;
 386         return;
 387
 388 fail2:
 389         wi_pcmcia_disable(sc);
 390 fail:
 391         pcmcia_function_unconfigure(pa->pf);
 392 }
 393
 394 static int
 395 wi_pcmcia_detach(device_t self, int flags)
 396 {
 397         struct wi_pcmcia_softc *psc = (struct wi_pcmcia_softc *)self;
 398         int error;
 399
 400         if (psc->sc_state != WI_PCMCIA_ATTACHED)
 401                 return (0);
 402
 403         error = wi_detach(&psc->sc_wi);
 404         if (error != 0)
 405                 return (error);
 406
 407         pcmcia_function_unconfigure(psc->sc_pf);
 408
 409         return (0);
 410 }
 411
 412 /*
 413  * Special routines to download firmware for Symbol CF card.
 414  * XXX: This should be modified generic into any PRISM-2 based card.
 415  */
 416
 417 #define WI_SBCF_PDIADDR         0x3100
 418
 419 /* unaligned load little endian */
 420 #define GETLE32(p)      ((p)[0] | ((p)[1]<<8) | ((p)[2]<<16) | ((p)[3]<<24))
 421 #define GETLE16(p)      ((p)[0] | ((p)[1]<<8))
 422
 423 #if WI_PCMCIA_SPECTRUM24T_FW
 424 static int
 425 wi_pcmcia_load_firm(struct wi_softc *sc, const void *primsym, int primlen, const void *secsym, int seclen)
 426 {
 427         u_int8_t ebuf[256];
 428         int i;
 429
 430         /* load primary code and run it */
 431         wi_pcmcia_set_hcr(sc, WI_HCR_EEHOLD);
 432         if (wi_pcmcia_write_firm(sc, primsym, primlen, NULL, 0))
 433                 return EIO;
 434         wi_pcmcia_set_hcr(sc, WI_HCR_RUN);
 435         for (i = 0; ; i++) {
 436                 if (i == 10)
 437                         return ETIMEDOUT;
 438                 tsleep(sc, PWAIT, "wiinit", 1);
 439                 if (CSR_READ_2(sc, WI_CNTL) == WI_CNTL_AUX_ENA_STAT)
 440                         break;
 441                 /* write the magic key value to unlock aux port */
 442                 CSR_WRITE_2(sc, WI_PARAM0, WI_AUX_KEY0);
 443                 CSR_WRITE_2(sc, WI_PARAM1, WI_AUX_KEY1);
 444                 CSR_WRITE_2(sc, WI_PARAM2, WI_AUX_KEY2);
 445                 CSR_WRITE_2(sc, WI_CNTL, WI_CNTL_AUX_ENA_CNTL);
 446         }
 447
 448         /* issue read EEPROM command: XXX copied from wi_cmd() */
 449         CSR_WRITE_2(sc, WI_PARAM0, 0);
 450         CSR_WRITE_2(sc, WI_PARAM1, 0);
 451         CSR_WRITE_2(sc, WI_PARAM2, 0);
 452         CSR_WRITE_2(sc, WI_COMMAND, WI_CMD_READEE);
 453         for (i = 0; i < WI_TIMEOUT; i++) {
 454                 if (CSR_READ_2(sc, WI_EVENT_STAT) & WI_EV_CMD)
 455                         break;
 456                 DELAY(1);
 457         }
 458         CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_CMD);
 459
 460         CSR_WRITE_2(sc, WI_AUX_PAGE, WI_SBCF_PDIADDR / WI_AUX_PGSZ);
 461         CSR_WRITE_2(sc, WI_AUX_OFFSET, WI_SBCF_PDIADDR % WI_AUX_PGSZ);
 462         CSR_READ_MULTI_STREAM_2(sc, WI_AUX_DATA,
 463             (u_int16_t *)ebuf, sizeof(ebuf) / 2);
 464         if (GETLE16(ebuf) > sizeof(ebuf))
 465                 return EIO;
 466         if (wi_pcmcia_write_firm(sc, secsym, seclen, ebuf + 4, GETLE16(ebuf)))
 467                 return EIO;
 468         return 0;
 469 }
 470
 471 static int
 472 wi_pcmcia_write_firm(struct wi_softc *sc, const void *buf, int buflen, const void *ebuf, int ebuflen)
 473 {
 474         const u_int8_t *p, *ep, *q, *eq;
 475         char *endp;
 476         u_int32_t addr, id, eid;
 477         int i, len, elen, nblk, pdrlen;
 478
 479         /*
 480          * Parse the header of the firmware image.
 481          */
 482         p = buf;
 483         ep = p + buflen;
 484         while (p < ep && *p++ != ' ');  /* FILE: */
 485         while (p < ep && *p++ != ' ');  /* filename */
 486         while (p < ep && *p++ != ' ');  /* type of the firmware */
 487         nblk = strtoul(p, &endp, 10);
 488         p = (void *)endp;
 489         pdrlen = strtoul(p + 1, &endp, 10);
 490         p = (void *)endp;
 491         while (p < ep && *p++ != 0x1a); /* skip rest of header */
 492
 493         /*
 494          * Block records: address[4], length[2], data[length];
 495          */
 496         for (i = 0; i < nblk; i++) {
 497                 addr = GETLE32(p);      p += 4;
 498                 len  = GETLE16(p);      p += 2;
 499                 CSR_WRITE_2(sc, WI_AUX_PAGE, addr / WI_AUX_PGSZ);
 500                 CSR_WRITE_2(sc, WI_AUX_OFFSET, addr % WI_AUX_PGSZ);
 501                 CSR_WRITE_MULTI_STREAM_2(sc, WI_AUX_DATA,
 502                     (const u_int16_t *)p, len / 2);
 503                 p += len;
 504         }
 505
 506         /*
 507          * PDR: id[4], address[4], length[4];
 508          */
 509         for (i = 0; i < pdrlen; ) {
 510                 id   = GETLE32(p);      p += 4; i += 4;
 511                 addr = GETLE32(p);      p += 4; i += 4;
 512                 len  = GETLE32(p);      p += 4; i += 4;
 513                 /* replace PDR entry with the values from EEPROM, if any */
 514                 for (q = ebuf, eq = q + ebuflen; q < eq; q += elen * 2) {
 515                         elen = GETLE16(q);      q += 2;
 516                         eid  = GETLE16(q);      q += 2;
 517                         elen--;         /* elen includes eid */
 518                         if (eid == 0)
 519                                 break;
 520                         if (eid != id)
 521                                 continue;
 522                         CSR_WRITE_2(sc, WI_AUX_PAGE, addr / WI_AUX_PGSZ);
 523                         CSR_WRITE_2(sc, WI_AUX_OFFSET, addr % WI_AUX_PGSZ);
 524                         CSR_WRITE_MULTI_STREAM_2(sc, WI_AUX_DATA,
 525                             (const u_int16_t *)q, len / 2);
 526                         break;
 527                 }
 528         }
 529         return 0;
 530 }
 531
 532 static int
 533 wi_pcmcia_set_hcr(struct wi_softc *sc, int mode)
 534 {
 535         u_int16_t hcr;
 536
 537         CSR_WRITE_2(sc, WI_COR, WI_COR_RESET);
 538         tsleep(sc, PWAIT, "wiinit", 1);
 539         hcr = CSR_READ_2(sc, WI_HCR);
 540         hcr = (hcr & WI_HCR_4WIRE) | (mode & ~WI_HCR_4WIRE);
 541         CSR_WRITE_2(sc, WI_HCR, hcr);
 542         tsleep(sc, PWAIT, "wiinit", 1);
 543         CSR_WRITE_2(sc, WI_COR, WI_COR_IOMODE);
 544         tsleep(sc, PWAIT, "wiinit", 1);
 545         return 0;
 546 }
 547 #endif