1 /*
   2  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
   3  * Use is subject to license terms.
   4  */
   5 
   6 /*
   7  * Copyright(c) 2004
   8  *      Damien Bergamini <damien.bergamini@free.fr>. All rights reserved.
   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 unmodified, this list of conditions, and the following
  15  *    disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32 
  33 #include <sys/types.h>
  34 #include <sys/byteorder.h>
  35 #include <sys/conf.h>
  36 #include <sys/cmn_err.h>
  37 #include <sys/stat.h>
  38 #include <sys/ddi.h>
  39 #include <sys/sunddi.h>
  40 #include <sys/strsubr.h>
  41 #include <sys/ethernet.h>
  42 #include <inet/common.h>
  43 #include <inet/nd.h>
  44 #include <inet/mi.h>
  45 #include <sys/note.h>
  46 #include <sys/stream.h>
  47 #include <sys/strsun.h>
  48 #include <sys/modctl.h>
  49 #include <sys/devops.h>
  50 #include <sys/dlpi.h>
  51 #include <sys/mac_provider.h>
  52 #include <net/if.h>
  53 #include <sys/mac_wifi.h>
  54 #include <sys/varargs.h>
  55 #include <sys/policy.h>
  56 
  57 #include "ipw2100.h"
  58 #include "ipw2100_impl.h"
  59 #include <inet/wifi_ioctl.h>
  60 
  61 /*
  62  * kCF framework include files
  63  */
  64 #include <sys/crypto/common.h>
  65 #include <sys/crypto/api.h>
  66 
  67 static void   *ipw2100_ssp      = NULL;
  68 static char   ipw2100_ident[]   = IPW2100_DRV_DESC;
  69 
  70 /*
  71  * PIO access attribute for register
  72  */
  73 static ddi_device_acc_attr_t ipw2100_csr_accattr = {
  74         DDI_DEVICE_ATTR_V0,
  75         DDI_STRUCTURE_LE_ACC,
  76         DDI_STRICTORDER_ACC
  77 };
  78 
  79 static ddi_device_acc_attr_t ipw2100_dma_accattr = {
  80         DDI_DEVICE_ATTR_V0,
  81         DDI_NEVERSWAP_ACC,
  82         DDI_STRICTORDER_ACC
  83 };
  84 
  85 static ddi_dma_attr_t ipw2100_dma_attr = {
  86         DMA_ATTR_V0,
  87         0x0000000000000000ULL,
  88         0x00000000ffffffffULL,
  89         0x00000000ffffffffULL,
  90         0x0000000000000004ULL,
  91         0xfff,
  92         1,
  93         0x00000000ffffffffULL,
  94         0x00000000ffffffffULL,
  95         1,
  96         1,
  97         0
  98 };
  99 
 100 static const struct ieee80211_rateset ipw2100_rateset_11b = { 4,
 101         {2, 4, 11, 22}
 102 };
 103 
 104 /*
 105  * For mfthread only
 106  */
 107 extern pri_t minclsyspri;
 108 
 109 /*
 110  * ipw2100 specific hardware operations
 111  */
 112 static void     ipw2100_hwconf_get(struct ipw2100_softc *sc);
 113 static int      ipw2100_chip_reset(struct ipw2100_softc *sc);
 114 static void     ipw2100_master_stop(struct ipw2100_softc *sc);
 115 static void     ipw2100_stop(struct ipw2100_softc *sc);
 116 static int      ipw2100_config(struct ipw2100_softc *sc);
 117 static int      ipw2100_cmd(struct ipw2100_softc *sc, uint32_t type,
 118     void *buf, size_t len);
 119 static int      ipw2100_dma_region_alloc(struct ipw2100_softc *sc,
 120     struct dma_region *dr, size_t size, uint_t dir, uint_t flags);
 121 static void     ipw2100_dma_region_free(struct dma_region *dr);
 122 static void     ipw2100_tables_init(struct ipw2100_softc *sc);
 123 static void     ipw2100_ring_hwsetup(struct ipw2100_softc *sc);
 124 static int      ipw2100_ring_alloc(struct ipw2100_softc *sc);
 125 static void     ipw2100_ring_free(struct ipw2100_softc *sc);
 126 static void     ipw2100_ring_reset(struct ipw2100_softc *sc);
 127 static int      ipw2100_ring_init(struct ipw2100_softc *sc);
 128 
 129 /*
 130  * GLD specific operations
 131  */
 132 static int      ipw2100_m_stat(void *arg, uint_t stat, uint64_t *val);
 133 static int      ipw2100_m_start(void *arg);
 134 static void     ipw2100_m_stop(void *arg);
 135 static int      ipw2100_m_unicst(void *arg, const uint8_t *macaddr);
 136 static int      ipw2100_m_multicst(void *arg, boolean_t add, const uint8_t *m);
 137 static int      ipw2100_m_promisc(void *arg, boolean_t on);
 138 static mblk_t  *ipw2100_m_tx(void *arg, mblk_t *mp);
 139 static void     ipw2100_m_ioctl(void *arg, queue_t *wq, mblk_t *mp);
 140 static int      ipw2100_m_setprop(void *arg, const char *pr_name,
 141     mac_prop_id_t wldp_pr_num, uint_t wldp_length, const void *wldp_buf);
 142 static int      ipw2100_m_getprop(void *arg, const char *pr_name,
 143     mac_prop_id_t wldp_pr_num, uint_t wldp_length, void *wldp_buf);
 144 static void     ipw2100_m_propinfo(void *, const char *, mac_prop_id_t,
 145     mac_prop_info_handle_t);
 146 
 147 /*
 148  * Interrupt and Data transferring operations
 149  */
 150 static uint_t   ipw2100_intr(caddr_t arg);
 151 static int      ipw2100_send(struct ieee80211com *ic, mblk_t *mp, uint8_t type);
 152 static void     ipw2100_rcvpkt(struct ipw2100_softc *sc,
 153     struct ipw2100_status *status, uint8_t *rxbuf);
 154 
 155 /*
 156  * WiFi specific operations
 157  */
 158 static int      ipw2100_newstate(struct ieee80211com *ic,
 159     enum ieee80211_state state, int arg);
 160 static void     ipw2100_thread(struct ipw2100_softc *sc);
 161 
 162 /*
 163  * IOCTL Handler
 164  */
 165 static int      ipw2100_ioctl(struct ipw2100_softc *sc, queue_t *q, mblk_t *m);
 166 static int      ipw2100_getset(struct ipw2100_softc *sc,
 167     mblk_t *m, uint32_t cmd, boolean_t *need_net80211);
 168 static int      ipw_wificfg_radio(struct ipw2100_softc *sc,
 169     uint32_t cmd,  wldp_t *outfp);
 170 static int      ipw_wificfg_desrates(wldp_t *outfp);
 171 static int      ipw_wificfg_disassoc(struct ipw2100_softc *sc,
 172     wldp_t *outfp);
 173 
 174 /*
 175  * Suspend / Resume operations
 176  */
 177 static int      ipw2100_cpr_suspend(struct ipw2100_softc *sc);
 178 static int      ipw2100_cpr_resume(struct ipw2100_softc *sc);
 179 
 180 /*
 181  * Mac Call Back entries
 182  */
 183 mac_callbacks_t ipw2100_m_callbacks = {
 184         MC_IOCTL | MC_SETPROP | MC_GETPROP | MC_PROPINFO,
 185         ipw2100_m_stat,
 186         ipw2100_m_start,
 187         ipw2100_m_stop,
 188         ipw2100_m_promisc,
 189         ipw2100_m_multicst,
 190         ipw2100_m_unicst,
 191         ipw2100_m_tx,
 192         NULL,
 193         ipw2100_m_ioctl,
 194         NULL,
 195         NULL,
 196         NULL,
 197         ipw2100_m_setprop,
 198         ipw2100_m_getprop,
 199         ipw2100_m_propinfo
 200 };
 201 
 202 
 203 /*
 204  * DEBUG Facility
 205  */
 206 #define MAX_MSG (128)
 207 uint32_t ipw2100_debug = 0;
 208 /*
 209  * supported debug marsks:
 210  *      | IPW2100_DBG_INIT
 211  *      | IPW2100_DBG_GLD
 212  *      | IPW2100_DBG_TABLE
 213  *      | IPW2100_DBG_SOFTINT
 214  *      | IPW2100_DBG_CSR
 215  *      | IPW2100_DBG_INT
 216  *      | IPW2100_DBG_FW
 217  *      | IPW2100_DBG_IOCTL
 218  *      | IPW2100_DBG_HWCAP
 219  *      | IPW2100_DBG_STATISTIC
 220  *      | IPW2100_DBG_RING
 221  *      | IPW2100_DBG_WIFI
 222  *      | IPW2100_DBG_BRUSSELS
 223  */
 224 
 225 /*
 226  * global tuning parameters to work around unknown hardware issues
 227  */
 228 static uint32_t delay_config_stable     = 100000;       /* 100ms */
 229 static uint32_t delay_fatal_recover     = 100000 * 20;  /* 2s */
 230 static uint32_t delay_aux_thread        = 100000;       /* 100ms */
 231 
 232 void
 233 ipw2100_dbg(dev_info_t *dip, int level, const char *fmt, ...)
 234 {
 235         va_list ap;
 236         char    buf[MAX_MSG];
 237         int     instance;
 238 
 239         va_start(ap, fmt);
 240         (void) vsnprintf(buf, sizeof (buf), fmt, ap);
 241         va_end(ap);
 242 
 243         if (dip) {
 244                 instance = ddi_get_instance(dip);
 245                 cmn_err(level, "%s%d: %s", IPW2100_DRV_NAME, instance, buf);
 246         } else
 247                 cmn_err(level, "%s: %s", IPW2100_DRV_NAME, buf);
 248 }
 249 
 250 /*
 251  * device operations
 252  */
 253 int
 254 ipw2100_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 255 {
 256         struct ipw2100_softc    *sc;
 257         ddi_acc_handle_t        cfgh;
 258         caddr_t                 regs;
 259         struct ieee80211com     *ic;
 260         int                     instance, err, i;
 261         char                    strbuf[32];
 262         wifi_data_t             wd = { 0 };
 263         mac_register_t          *macp;
 264 
 265         switch (cmd) {
 266         case DDI_ATTACH:
 267                 break;
 268         case DDI_RESUME:
 269                 sc = ddi_get_soft_state(ipw2100_ssp, ddi_get_instance(dip));
 270                 if (sc == NULL) {
 271                         err = DDI_FAILURE;
 272                         goto fail1;
 273                 }
 274                 return (ipw2100_cpr_resume(sc));
 275         default:
 276                 err = DDI_FAILURE;
 277                 goto fail1;
 278         }
 279 
 280         instance = ddi_get_instance(dip);
 281         err = ddi_soft_state_zalloc(ipw2100_ssp, instance);
 282         if (err != DDI_SUCCESS) {
 283                 IPW2100_WARN((dip, CE_WARN,
 284                     "ipw2100_attach(): unable to allocate soft state\n"));
 285                 goto fail1;
 286         }
 287         sc = ddi_get_soft_state(ipw2100_ssp, instance);
 288         sc->sc_dip = dip;
 289 
 290         /*
 291          * Map config spaces register
 292          */
 293         err = ddi_regs_map_setup(dip, IPW2100_PCI_CFG_RNUM, &regs,
 294             0, 0, &ipw2100_csr_accattr, &cfgh);
 295         if (err != DDI_SUCCESS) {
 296                 IPW2100_WARN((dip, CE_WARN,
 297                     "ipw2100_attach(): unable to map spaces regs\n"));
 298                 goto fail2;
 299         }
 300         ddi_put8(cfgh, (uint8_t *)(regs + 0x41), 0);
 301         ddi_regs_map_free(&cfgh);
 302 
 303         /*
 304          * Map operating registers
 305          */
 306         err = ddi_regs_map_setup(dip, IPW2100_PCI_CSR_RNUM, &sc->sc_regs,
 307             0, 0, &ipw2100_csr_accattr, &sc->sc_ioh);
 308         if (err != DDI_SUCCESS) {
 309                 IPW2100_WARN((dip, CE_WARN,
 310                     "ipw2100_attach(): unable to map device regs\n"));
 311                 goto fail2;
 312         }
 313 
 314         /*
 315          * Reset the chip
 316          */
 317         err = ipw2100_chip_reset(sc);
 318         if (err != DDI_SUCCESS) {
 319                 IPW2100_WARN((dip, CE_WARN,
 320                     "ipw2100_attach(): reset failed\n"));
 321                 goto fail3;
 322         }
 323 
 324         /*
 325          * Get the hw conf, including MAC address, then init all rings.
 326          */
 327         ipw2100_hwconf_get(sc);
 328         err = ipw2100_ring_init(sc);
 329         if (err != DDI_SUCCESS) {
 330                 IPW2100_WARN((dip, CE_WARN,
 331                     "ipw2100_attach(): "
 332                     "unable to allocate and initialize rings\n"));
 333                 goto fail3;
 334         }
 335 
 336         /*
 337          * Initialize mutexs and condvars
 338          */
 339         err = ddi_get_iblock_cookie(dip, 0, &sc->sc_iblk);
 340         if (err != DDI_SUCCESS) {
 341                 IPW2100_WARN((dip, CE_WARN,
 342                     "ipw2100_attach(): ddi_get_iblock_cookie() failed\n"));
 343                 goto fail4;
 344         }
 345         /*
 346          * interrupt lock
 347          */
 348         mutex_init(&sc->sc_ilock, "interrupt-lock", MUTEX_DRIVER,
 349             (void *) sc->sc_iblk);
 350         cv_init(&sc->sc_fw_cond, "firmware", CV_DRIVER, NULL);
 351         cv_init(&sc->sc_cmd_cond, "command", CV_DRIVER, NULL);
 352         /*
 353          * tx ring lock
 354          */
 355         mutex_init(&sc->sc_tx_lock, "tx-ring", MUTEX_DRIVER,
 356             (void *) sc->sc_iblk);
 357         cv_init(&sc->sc_tx_cond, "tx-ring", CV_DRIVER, NULL);
 358         /*
 359          * rescheuled lock
 360          */
 361         mutex_init(&sc->sc_resched_lock, "reschedule-lock", MUTEX_DRIVER,
 362             (void *) sc->sc_iblk);
 363         /*
 364          * initialize the mfthread
 365          */
 366         mutex_init(&sc->sc_mflock, "function-lock", MUTEX_DRIVER,
 367             (void *) sc->sc_iblk);
 368         cv_init(&sc->sc_mfthread_cv, NULL, CV_DRIVER, NULL);
 369         sc->sc_mf_thread = NULL;
 370         sc->sc_mfthread_switch = 0;
 371         /*
 372          * Initialize the wifi part, which will be used by
 373          * generic layer
 374          */
 375         ic = &sc->sc_ic;
 376         ic->ic_phytype  = IEEE80211_T_DS;
 377         ic->ic_opmode   = IEEE80211_M_STA;
 378         ic->ic_state    = IEEE80211_S_INIT;
 379         ic->ic_maxrssi  = 49;
 380         /*
 381          * Future, could use s/w to handle encryption: IEEE80211_C_WEP
 382          * and need to add support for IEEE80211_C_IBSS
 383          */
 384         ic->ic_caps = IEEE80211_C_SHPREAMBLE | IEEE80211_C_TXPMGT |
 385             IEEE80211_C_PMGT;
 386         ic->ic_sup_rates[IEEE80211_MODE_11B] = ipw2100_rateset_11b;
 387         IEEE80211_ADDR_COPY(ic->ic_macaddr, sc->sc_macaddr);
 388         for (i = 1; i < 16; i++) {
 389                 if (sc->sc_chmask &(1 << i)) {
 390                         /* IEEE80211_CHAN_B */
 391                         ic->ic_sup_channels[i].ich_freq  = ieee80211_ieee2mhz(i,
 392                             IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_CCK);
 393                         ic->ic_sup_channels[i].ich_flags =
 394                             IEEE80211_CHAN_2GHZ | IEEE80211_CHAN_CCK;
 395                 }
 396         }
 397         ic->ic_ibss_chan = &ic->ic_sup_channels[0];
 398         ic->ic_xmit = ipw2100_send;
 399         /*
 400          * init Wifi layer
 401          */
 402         ieee80211_attach(ic);
 403 
 404         /*
 405          * Override 80211 default routines
 406          */
 407         ieee80211_media_init(ic);
 408         sc->sc_newstate = ic->ic_newstate;
 409         ic->ic_newstate = ipw2100_newstate;
 410         /*
 411          * initialize default tx key
 412          */
 413         ic->ic_def_txkey = 0;
 414         /*
 415          * Set the Authentication to AUTH_Open only.
 416          */
 417         sc->sc_authmode = IEEE80211_AUTH_OPEN;
 418 
 419         /*
 420          * Add the interrupt handler
 421          */
 422         err = ddi_add_intr(dip, 0, &sc->sc_iblk, NULL,
 423             ipw2100_intr, (caddr_t)sc);
 424         if (err != DDI_SUCCESS) {
 425                 IPW2100_WARN((dip, CE_WARN,
 426                     "ipw2100_attach(): ddi_add_intr() failed\n"));
 427                 goto fail5;
 428         }
 429 
 430         /*
 431          * Initialize pointer to device specific functions
 432          */
 433         wd.wd_secalloc = WIFI_SEC_NONE;
 434         wd.wd_opmode = ic->ic_opmode;
 435         IEEE80211_ADDR_COPY(wd.wd_bssid, ic->ic_bss->in_bssid);
 436 
 437         macp = mac_alloc(MAC_VERSION);
 438         if (err != 0) {
 439                 IPW2100_WARN((dip, CE_WARN,
 440                     "ipw2100_attach(): mac_alloc() failed\n"));
 441                 goto fail6;
 442         }
 443 
 444         macp->m_type_ident   = MAC_PLUGIN_IDENT_WIFI;
 445         macp->m_driver               = sc;
 446         macp->m_dip          = dip;
 447         macp->m_src_addr     = ic->ic_macaddr;
 448         macp->m_callbacks    = &ipw2100_m_callbacks;
 449         macp->m_min_sdu              = 0;
 450         macp->m_max_sdu              = IEEE80211_MTU;
 451         macp->m_pdata                = &wd;
 452         macp->m_pdata_size   = sizeof (wd);
 453 
 454         /*
 455          * Register the macp to mac
 456          */
 457         err = mac_register(macp, &ic->ic_mach);
 458         mac_free(macp);
 459         if (err != DDI_SUCCESS) {
 460                 IPW2100_WARN((dip, CE_WARN,
 461                     "ipw2100_attach(): mac_register() failed\n"));
 462                 goto fail6;
 463         }
 464 
 465         /*
 466          * Create minor node of type DDI_NT_NET_WIFI
 467          */
 468         (void) snprintf(strbuf, sizeof (strbuf), "%s%d",
 469             IPW2100_DRV_NAME, instance);
 470         err = ddi_create_minor_node(dip, strbuf, S_IFCHR,
 471             instance + 1, DDI_NT_NET_WIFI, 0);
 472         if (err != DDI_SUCCESS)
 473                 IPW2100_WARN((dip, CE_WARN,
 474                     "ipw2100_attach(): ddi_create_minor_node() failed\n"));
 475 
 476         /*
 477          * Cache firmware, always return true
 478          */
 479         (void) ipw2100_cache_firmware(sc);
 480 
 481         /*
 482          * Notify link is down now
 483          */
 484         mac_link_update(ic->ic_mach, LINK_STATE_DOWN);
 485 
 486         /*
 487          * create the mf thread to handle the link status,
 488          * recovery fatal error, etc.
 489          */
 490         sc->sc_mfthread_switch = 1;
 491         if (sc->sc_mf_thread == NULL)
 492                 sc->sc_mf_thread = thread_create((caddr_t)NULL, 0,
 493                     ipw2100_thread, sc, 0, &p0, TS_RUN, minclsyspri);
 494 
 495         return (DDI_SUCCESS);
 496 
 497 fail6:
 498         ddi_remove_intr(dip, 0, sc->sc_iblk);
 499 fail5:
 500         ieee80211_detach(ic);
 501 
 502         mutex_destroy(&sc->sc_ilock);
 503         mutex_destroy(&sc->sc_tx_lock);
 504         mutex_destroy(&sc->sc_mflock);
 505         mutex_destroy(&sc->sc_resched_lock);
 506         cv_destroy(&sc->sc_mfthread_cv);
 507         cv_destroy(&sc->sc_tx_cond);
 508         cv_destroy(&sc->sc_cmd_cond);
 509         cv_destroy(&sc->sc_fw_cond);
 510 fail4:
 511         ipw2100_ring_free(sc);
 512 fail3:
 513         ddi_regs_map_free(&sc->sc_ioh);
 514 fail2:
 515         ddi_soft_state_free(ipw2100_ssp, instance);
 516 fail1:
 517         return (err);
 518 }
 519 
 520 int
 521 ipw2100_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
 522 {
 523         struct ipw2100_softc    *sc =
 524             ddi_get_soft_state(ipw2100_ssp, ddi_get_instance(dip));
 525         int err;
 526 
 527         ASSERT(sc != NULL);
 528 
 529         switch (cmd) {
 530         case DDI_DETACH:
 531                 break;
 532         case DDI_SUSPEND:
 533                 return (ipw2100_cpr_suspend(sc));
 534         default:
 535                 return (DDI_FAILURE);
 536         }
 537 
 538         /*
 539          * Destroy the mf_thread
 540          */
 541         mutex_enter(&sc->sc_mflock);
 542         sc->sc_mfthread_switch = 0;
 543         while (sc->sc_mf_thread != NULL) {
 544                 if (cv_wait_sig(&sc->sc_mfthread_cv, &sc->sc_mflock) == 0)
 545                         break;
 546         }
 547         mutex_exit(&sc->sc_mflock);
 548 
 549         /*
 550          * Unregister from the MAC layer subsystem
 551          */
 552         err = mac_unregister(sc->sc_ic.ic_mach);
 553         if (err != DDI_SUCCESS)
 554                 return (err);
 555 
 556         ddi_remove_intr(dip, 0, sc->sc_iblk);
 557 
 558         /*
 559          * destroy the cv
 560          */
 561         mutex_destroy(&sc->sc_ilock);
 562         mutex_destroy(&sc->sc_tx_lock);
 563         mutex_destroy(&sc->sc_mflock);
 564         mutex_destroy(&sc->sc_resched_lock);
 565         cv_destroy(&sc->sc_mfthread_cv);
 566         cv_destroy(&sc->sc_tx_cond);
 567         cv_destroy(&sc->sc_cmd_cond);
 568         cv_destroy(&sc->sc_fw_cond);
 569 
 570         /*
 571          * detach ieee80211
 572          */
 573         ieee80211_detach(&sc->sc_ic);
 574 
 575         (void) ipw2100_free_firmware(sc);
 576         ipw2100_ring_free(sc);
 577 
 578         ddi_regs_map_free(&sc->sc_ioh);
 579         ddi_remove_minor_node(dip, NULL);
 580         ddi_soft_state_free(ipw2100_ssp, ddi_get_instance(dip));
 581 
 582         return (DDI_SUCCESS);
 583 }
 584 
 585 int
 586 ipw2100_cpr_suspend(struct ipw2100_softc *sc)
 587 {
 588         IPW2100_DBG(IPW2100_DBG_INIT, (sc->sc_dip, CE_CONT,
 589             "ipw2100_cpr_suspend(): enter\n"));
 590 
 591         /*
 592          * Destroy the mf_thread
 593          */
 594         mutex_enter(&sc->sc_mflock);
 595         sc->sc_mfthread_switch = 0;
 596         while (sc->sc_mf_thread != NULL) {
 597                 if (cv_wait_sig(&sc->sc_mfthread_cv, &sc->sc_mflock) == 0)
 598                         break;
 599         }
 600         mutex_exit(&sc->sc_mflock);
 601 
 602         /*
 603          * stop the hardware; this mask all interrupts
 604          */
 605         ipw2100_stop(sc);
 606         sc->sc_flags &= ~IPW2100_FLAG_RUNNING;
 607         sc->sc_suspended = 1;
 608 
 609         (void) ipw2100_free_firmware(sc);
 610         ipw2100_ring_free(sc);
 611 
 612         return (DDI_SUCCESS);
 613 }
 614 
 615 int
 616 ipw2100_cpr_resume(struct ipw2100_softc *sc)
 617 {
 618         struct ieee80211com     *ic = &sc->sc_ic;
 619         dev_info_t              *dip = sc->sc_dip;
 620         int                     err;
 621 
 622         IPW2100_DBG(IPW2100_DBG_INIT, (sc->sc_dip, CE_CONT,
 623             "ipw2100_cpr_resume(): enter\n"));
 624 
 625         /*
 626          * Reset the chip
 627          */
 628         err = ipw2100_chip_reset(sc);
 629         if (err != DDI_SUCCESS) {
 630                 IPW2100_WARN((dip, CE_WARN,
 631                     "ipw2100_attach(): reset failed\n"));
 632                 return (DDI_FAILURE);
 633         }
 634 
 635         /*
 636          * Get the hw conf, including MAC address, then init all rings.
 637          */
 638         /* ipw2100_hwconf_get(sc); */
 639         err = ipw2100_ring_init(sc);
 640         if (err != DDI_SUCCESS) {
 641                 IPW2100_WARN((dip, CE_WARN,
 642                     "ipw2100_attach(): "
 643                     "unable to allocate and initialize rings\n"));
 644                 return (DDI_FAILURE);
 645         }
 646 
 647         /*
 648          * Cache firmware, always return true
 649          */
 650         (void) ipw2100_cache_firmware(sc);
 651 
 652         /*
 653          * Notify link is down now
 654          */
 655         mac_link_update(ic->ic_mach, LINK_STATE_DOWN);
 656 
 657         /*
 658          * create the mf thread to handle the link status,
 659          * recovery fatal error, etc.
 660          */
 661         sc->sc_mfthread_switch = 1;
 662         if (sc->sc_mf_thread == NULL)
 663                 sc->sc_mf_thread = thread_create((caddr_t)NULL, 0,
 664                     ipw2100_thread, sc, 0, &p0, TS_RUN, minclsyspri);
 665 
 666         /*
 667          * enable all interrupts
 668          */
 669         sc->sc_suspended = 0;
 670         ipw2100_csr_put32(sc, IPW2100_CSR_INTR_MASK, IPW2100_INTR_MASK_ALL);
 671 
 672         /*
 673          * initialize ipw2100 hardware
 674          */
 675         (void) ipw2100_init(sc);
 676 
 677         sc->sc_flags |= IPW2100_FLAG_RUNNING;
 678 
 679         return (DDI_SUCCESS);
 680 }
 681 
 682 /*
 683  * quiesce(9E) entry point.
 684  * This function is called when the system is single-threaded at high
 685  * PIL with preemption disabled. Therefore, this function must not be
 686  * blocked.
 687  * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
 688  * DDI_FAILURE indicates an error condition and should almost never happen.
 689  * Contributed by Juergen Keil, <jk@tools.de>.
 690  */
 691 static int
 692 ipw2100_quiesce(dev_info_t *dip)
 693 {
 694         struct ipw2100_softc    *sc =
 695             ddi_get_soft_state(ipw2100_ssp, ddi_get_instance(dip));
 696 
 697         if (sc == NULL)
 698                 return (DDI_FAILURE);
 699 
 700         /*
 701          * No more blocking is allowed while we are in the
 702          * quiesce(9E) entry point.
 703          */
 704         sc->sc_flags |= IPW2100_FLAG_QUIESCED;
 705 
 706         /*
 707          * Disable and mask all interrupts.
 708          */
 709         ipw2100_stop(sc);
 710         return (DDI_SUCCESS);
 711 }
 712 
 713 static void
 714 ipw2100_tables_init(struct ipw2100_softc *sc)
 715 {
 716         sc->sc_table1_base = ipw2100_csr_get32(sc, IPW2100_CSR_TABLE1_BASE);
 717         sc->sc_table2_base = ipw2100_csr_get32(sc, IPW2100_CSR_TABLE2_BASE);
 718 }
 719 
 720 static void
 721 ipw2100_stop(struct ipw2100_softc *sc)
 722 {
 723         struct ieee80211com     *ic = &sc->sc_ic;
 724 
 725         ipw2100_master_stop(sc);
 726         ipw2100_csr_put32(sc, IPW2100_CSR_RST, IPW2100_RST_SW_RESET);
 727         sc->sc_flags &= ~IPW2100_FLAG_FW_INITED;
 728 
 729         if (!(sc->sc_flags & IPW2100_FLAG_QUIESCED))
 730                 ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
 731 }
 732 
 733 static int
 734 ipw2100_config(struct ipw2100_softc *sc)
 735 {
 736         struct ieee80211com             *ic = &sc->sc_ic;
 737         struct ipw2100_security         sec;
 738         struct ipw2100_wep_key          wkey;
 739         struct ipw2100_scan_options     sopt;
 740         struct ipw2100_configuration    cfg;
 741         uint32_t                        data;
 742         int                             err, i;
 743 
 744         /*
 745          * operation mode
 746          */
 747         switch (ic->ic_opmode) {
 748         case IEEE80211_M_STA:
 749         case IEEE80211_M_HOSTAP:
 750                 data = LE_32(IPW2100_MODE_BSS);
 751                 break;
 752 
 753         case IEEE80211_M_IBSS:
 754         case IEEE80211_M_AHDEMO:
 755                 data = LE_32(IPW2100_MODE_IBSS);
 756                 break;
 757         }
 758 
 759         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 760             "ipw2100_config(): Setting mode to %u\n", LE_32(data)));
 761 
 762         err = ipw2100_cmd(sc, IPW2100_CMD_SET_MODE,
 763             &data, sizeof (data));
 764         if (err != DDI_SUCCESS)
 765                 return (err);
 766 
 767         /*
 768          * operation channel if IBSS or MONITOR
 769          */
 770         if (ic->ic_opmode == IEEE80211_M_IBSS) {
 771 
 772                 data = LE_32(ieee80211_chan2ieee(ic, ic->ic_ibss_chan));
 773 
 774                 IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 775                     "ipw2100_config(): Setting channel to %u\n", LE_32(data)));
 776 
 777                 err = ipw2100_cmd(sc, IPW2100_CMD_SET_CHANNEL,
 778                     &data, sizeof (data));
 779                 if (err != DDI_SUCCESS)
 780                         return (err);
 781         }
 782 
 783         /*
 784          * set MAC address
 785          */
 786         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 787             "ipw2100_config(): Setting MAC address to "
 788             "%02x:%02x:%02x:%02x:%02x:%02x\n",
 789             ic->ic_macaddr[0], ic->ic_macaddr[1], ic->ic_macaddr[2],
 790             ic->ic_macaddr[3], ic->ic_macaddr[4], ic->ic_macaddr[5]));
 791         err = ipw2100_cmd(sc, IPW2100_CMD_SET_MAC_ADDRESS, ic->ic_macaddr,
 792             IEEE80211_ADDR_LEN);
 793         if (err != DDI_SUCCESS)
 794                 return (err);
 795 
 796         /*
 797          * configuration capabilities
 798          */
 799         cfg.flags = IPW2100_CFG_BSS_MASK | IPW2100_CFG_IBSS_MASK |
 800             IPW2100_CFG_PREAMBLE_AUTO | IPW2100_CFG_802_1x_ENABLE;
 801         if (ic->ic_opmode == IEEE80211_M_IBSS)
 802                 cfg.flags |= IPW2100_CFG_IBSS_AUTO_START;
 803         if (sc->if_flags & IFF_PROMISC)
 804                 cfg.flags |= IPW2100_CFG_PROMISCUOUS;
 805         cfg.flags       = LE_32(cfg.flags);
 806         cfg.bss_chan    = LE_32(sc->sc_chmask >> 1);
 807         cfg.ibss_chan   = LE_32(sc->sc_chmask >> 1);
 808 
 809         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 810             "ipw2100_config(): Setting configuration to 0x%x\n",
 811             LE_32(cfg.flags)));
 812 
 813         err = ipw2100_cmd(sc, IPW2100_CMD_SET_CONFIGURATION,
 814             &cfg, sizeof (cfg));
 815 
 816         if (err != DDI_SUCCESS)
 817                 return (err);
 818 
 819         /*
 820          * set 802.11 Tx rates
 821          */
 822         data = LE_32(0x3);  /* 1, 2 */
 823         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 824             "ipw2100_config(): Setting 802.11 Tx rates to 0x%x\n",
 825             LE_32(data)));
 826         err = ipw2100_cmd(sc, IPW2100_CMD_SET_BASIC_TX_RATES,
 827             &data, sizeof (data));
 828         if (err != DDI_SUCCESS)
 829                 return (err);
 830 
 831         /*
 832          * set 802.11b Tx rates
 833          */
 834         data = LE_32(0xf);  /* 1, 2, 5.5, 11 */
 835         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 836             "ipw2100_config(): Setting 802.11b Tx rates to 0x%x\n",
 837             LE_32(data)));
 838         err = ipw2100_cmd(sc, IPW2100_CMD_SET_TX_RATES, &data, sizeof (data));
 839         if (err != DDI_SUCCESS)
 840                 return (err);
 841 
 842         /*
 843          * set power mode
 844          */
 845         data = LE_32(IPW2100_POWER_MODE_CAM);
 846         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 847             "ipw2100_config(): Setting power mode to %u\n", LE_32(data)));
 848         err = ipw2100_cmd(sc, IPW2100_CMD_SET_POWER_MODE, &data, sizeof (data));
 849         if (err != DDI_SUCCESS)
 850                 return (err);
 851 
 852         /*
 853          * set power index
 854          */
 855         if (ic->ic_opmode == IEEE80211_M_IBSS) {
 856                 data = LE_32(32);
 857                 IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 858                     "ipw2100_config(): Setting Tx power index to %u\n",
 859                     LE_32(data)));
 860                 err = ipw2100_cmd(sc, IPW2100_CMD_SET_TX_POWER_INDEX,
 861                     &data, sizeof (data));
 862                 if (err != DDI_SUCCESS)
 863                         return (err);
 864         }
 865 
 866         /*
 867          * set RTS threshold
 868          */
 869         ic->ic_rtsthreshold = 2346;
 870         data = LE_32(ic->ic_rtsthreshold);
 871         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 872             "ipw2100_config(): Setting RTS threshold to %u\n", LE_32(data)));
 873         err = ipw2100_cmd(sc, IPW2100_CMD_SET_RTS_THRESHOLD,
 874             &data, sizeof (data));
 875         if (err != DDI_SUCCESS)
 876                 return (err);
 877 
 878         /*
 879          * set frag threshold
 880          */
 881         ic->ic_fragthreshold = 2346;
 882         data = LE_32(ic->ic_fragthreshold);
 883         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 884             "ipw2100_config(): Setting frag threshold to %u\n", LE_32(data)));
 885         err = ipw2100_cmd(sc, IPW2100_CMD_SET_FRAG_THRESHOLD,
 886             &data, sizeof (data));
 887         if (err != DDI_SUCCESS)
 888                 return (err);
 889 
 890         /*
 891          * set ESSID
 892          */
 893         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 894             "ipw2100_config(): Setting ESSID to %u, ESSID[0]%c\n",
 895             ic->ic_des_esslen, ic->ic_des_essid[0]));
 896         err = ipw2100_cmd(sc, IPW2100_CMD_SET_ESSID,
 897             ic->ic_des_essid, ic->ic_des_esslen);
 898         if (err != DDI_SUCCESS)
 899                 return (err);
 900 
 901         /*
 902          * no mandatory BSSID
 903          */
 904         err = ipw2100_cmd(sc, IPW2100_CMD_SET_MANDATORY_BSSID, NULL, 0);
 905         if (err != DDI_SUCCESS)
 906                 return (err);
 907 
 908         /*
 909          * set BSSID, if any
 910          */
 911         if (ic->ic_flags & IEEE80211_F_DESBSSID) {
 912                 IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 913                     "ipw2100_config(): Setting BSSID to %u\n",
 914                     IEEE80211_ADDR_LEN));
 915                 err = ipw2100_cmd(sc, IPW2100_CMD_SET_DESIRED_BSSID,
 916                     ic->ic_des_bssid, IEEE80211_ADDR_LEN);
 917                 if (err != DDI_SUCCESS)
 918                         return (err);
 919         }
 920 
 921         /*
 922          * set security information
 923          */
 924         (void) memset(&sec, 0, sizeof (sec));
 925         /*
 926          * use the value set to ic_bss to retrieve current sharedmode
 927          */
 928         sec.authmode = (ic->ic_bss->in_authmode == WL_SHAREDKEY) ?
 929             IPW2100_AUTH_SHARED : IPW2100_AUTH_OPEN;
 930         sec.ciphers = LE_32(IPW2100_CIPHER_NONE);
 931         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 932             "ipw2100_config(): Setting authmode to %u\n", sec.authmode));
 933         err = ipw2100_cmd(sc, IPW2100_CMD_SET_SECURITY_INFORMATION,
 934             &sec, sizeof (sec));
 935         if (err != DDI_SUCCESS)
 936                 return (err);
 937 
 938         /*
 939          * set WEP if any
 940          */
 941         if (ic->ic_flags & IEEE80211_F_PRIVACY) {
 942                 for (i = 0; i < IEEE80211_WEP_NKID; i++) {
 943                         if (ic->ic_nw_keys[i].wk_keylen == 0)
 944                                 continue;
 945                         wkey.idx = (uint8_t)i;
 946                         wkey.len = ic->ic_nw_keys[i].wk_keylen;
 947                         (void) memset(wkey.key, 0, sizeof (wkey.key));
 948                         if (ic->ic_nw_keys[i].wk_keylen)
 949                                 (void) memcpy(wkey.key,
 950                                     ic->ic_nw_keys[i].wk_key,
 951                                     ic->ic_nw_keys[i].wk_keylen);
 952                         err = ipw2100_cmd(sc, IPW2100_CMD_SET_WEP_KEY,
 953                             &wkey, sizeof (wkey));
 954                         if (err != DDI_SUCCESS)
 955                                 return (err);
 956                 }
 957                 data = LE_32(ic->ic_def_txkey);
 958                 err = ipw2100_cmd(sc, IPW2100_CMD_SET_WEP_KEY_INDEX,
 959                     &data, sizeof (data));
 960                 if (err != DDI_SUCCESS)
 961                         return (err);
 962         }
 963 
 964         /*
 965          * turn on WEP
 966          */
 967         data = LE_32((ic->ic_flags & IEEE80211_F_PRIVACY) ? 0x8 : 0);
 968         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 969             "ipw2100_config(): Setting WEP flags to %u\n", LE_32(data)));
 970         err = ipw2100_cmd(sc, IPW2100_CMD_SET_WEP_FLAGS, &data, sizeof (data));
 971         if (err != DDI_SUCCESS)
 972                 return (err);
 973 
 974         /*
 975          * set beacon interval if IBSS or HostAP
 976          */
 977         if (ic->ic_opmode == IEEE80211_M_IBSS ||
 978             ic->ic_opmode == IEEE80211_M_HOSTAP) {
 979 
 980                 data = LE_32(ic->ic_lintval);
 981                 IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
 982                     "ipw2100_config(): Setting beacon interval to %u\n",
 983                     LE_32(data)));
 984                 err = ipw2100_cmd(sc, IPW2100_CMD_SET_BEACON_INTERVAL,
 985                     &data, sizeof (data));
 986                 if (err != DDI_SUCCESS)
 987                         return (err);
 988         }
 989 
 990         /*
 991          * set scan options
 992          */
 993         sopt.flags = LE_32(0);
 994         sopt.channels = LE_32(sc->sc_chmask >> 1);
 995         err = ipw2100_cmd(sc, IPW2100_CMD_SET_SCAN_OPTIONS,
 996             &sopt, sizeof (sopt));
 997         if (err != DDI_SUCCESS)
 998                 return (err);
 999 
1000 en_adapter:
1001 
1002         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
1003             "ipw2100_config(): Enabling adapter\n"));
1004 
1005         return (ipw2100_cmd(sc, IPW2100_CMD_ENABLE, NULL, 0));
1006 }
1007 
1008 static int
1009 ipw2100_cmd(struct ipw2100_softc *sc, uint32_t type, void *buf, size_t len)
1010 {
1011         struct ipw2100_bd       *txbd;
1012         clock_t                 clk;
1013         uint32_t                idx;
1014 
1015         /*
1016          * prepare command buffer
1017          */
1018         sc->sc_cmd->type = LE_32(type);
1019         sc->sc_cmd->subtype = LE_32(0);
1020         sc->sc_cmd->seq = LE_32(0);
1021         /*
1022          * copy data if any
1023          */
1024         if (len && buf)
1025                 (void) memcpy(sc->sc_cmd->data, buf, len);
1026         sc->sc_cmd->len = LE_32(len);
1027 
1028         /*
1029          * get host & device descriptor to submit command
1030          */
1031         mutex_enter(&sc->sc_tx_lock);
1032 
1033         IPW2100_DBG(IPW2100_DBG_RING, (sc->sc_dip, CE_CONT,
1034             "ipw2100_cmd(): tx-free=%d\n", sc->sc_tx_free));
1035 
1036         /*
1037          * command need 1 descriptor
1038          */
1039         while (sc->sc_tx_free < 1)  {
1040                 sc->sc_flags |= IPW2100_FLAG_CMD_WAIT;
1041                 cv_wait(&sc->sc_tx_cond, &sc->sc_tx_lock);
1042         }
1043         idx = sc->sc_tx_cur;
1044 
1045         IPW2100_DBG(IPW2100_DBG_RING, (sc->sc_dip, CE_CONT,
1046             "ipw2100_cmd(): tx-cur=%d\n", idx));
1047 
1048         sc->sc_done = 0;
1049 
1050         txbd            = &sc->sc_txbd[idx];
1051         txbd->phyaddr        = LE_32(sc->sc_dma_cmd.dr_pbase);
1052         txbd->len    = LE_32(sizeof (struct ipw2100_cmd));
1053         txbd->flags  = IPW2100_BD_FLAG_TX_FRAME_COMMAND
1054             | IPW2100_BD_FLAG_TX_LAST_FRAGMENT;
1055         txbd->nfrag  = 1;
1056         /*
1057          * sync for device
1058          */
1059         (void) ddi_dma_sync(sc->sc_dma_cmd.dr_hnd, 0,
1060             sizeof (struct ipw2100_cmd), DDI_DMA_SYNC_FORDEV);
1061         (void) ddi_dma_sync(sc->sc_dma_txbd.dr_hnd,
1062             idx * sizeof (struct ipw2100_bd),
1063             sizeof (struct ipw2100_bd), DDI_DMA_SYNC_FORDEV);
1064 
1065         /*
1066          * ring move forward
1067          */
1068         sc->sc_tx_cur = RING_FORWARD(sc->sc_tx_cur, 1, IPW2100_NUM_TXBD);
1069         sc->sc_tx_free--;
1070         ipw2100_csr_put32(sc, IPW2100_CSR_TX_WRITE_INDEX, sc->sc_tx_cur);
1071         mutex_exit(&sc->sc_tx_lock);
1072 
1073         /*
1074          * wait for command done
1075          */
1076         clk = drv_sectohz(1);
1077         mutex_enter(&sc->sc_ilock);
1078         while (sc->sc_done == 0) {
1079                 /*
1080                  * pending for the response
1081                  */
1082                 if (cv_reltimedwait(&sc->sc_cmd_cond, &sc->sc_ilock,
1083                     clk, TR_CLOCK_TICK) < 0)
1084                         break;
1085         }
1086         mutex_exit(&sc->sc_ilock);
1087 
1088         IPW2100_DBG(IPW2100_DBG_RING, (sc->sc_dip, CE_CONT,
1089             "ipw2100_cmd(): cmd-done=%s\n", sc->sc_done ? "yes" : "no"));
1090 
1091         if (sc->sc_done == 0)
1092                 return (DDI_FAILURE);
1093 
1094         return (DDI_SUCCESS);
1095 }
1096 
1097 int
1098 ipw2100_init(struct ipw2100_softc *sc)
1099 {
1100         int     err;
1101 
1102         IPW2100_DBG(IPW2100_DBG_INIT, (sc->sc_dip, CE_CONT,
1103             "ipw2100_init(): enter\n"));
1104 
1105         /*
1106          * no firmware is available, return fail directly
1107          */
1108         if (!(sc->sc_flags & IPW2100_FLAG_FW_CACHED)) {
1109                 IPW2100_WARN((sc->sc_dip, CE_WARN,
1110                     "ipw2100_init(): no firmware is available\n"));
1111                 return (DDI_FAILURE);
1112         }
1113 
1114         ipw2100_stop(sc);
1115 
1116         err = ipw2100_chip_reset(sc);
1117         if (err != DDI_SUCCESS) {
1118                 IPW2100_WARN((sc->sc_dip, CE_WARN,
1119                     "ipw2100_init(): could not reset adapter\n"));
1120                 goto fail;
1121         }
1122 
1123         /*
1124          * load microcode
1125          */
1126         IPW2100_DBG(IPW2100_DBG_INIT, (sc->sc_dip, CE_CONT,
1127             "ipw2100_init(): loading microcode\n"));
1128         err = ipw2100_load_uc(sc);
1129         if (err != DDI_SUCCESS) {
1130                 IPW2100_WARN((sc->sc_dip, CE_WARN,
1131                     "ipw2100_init(): could not load microcode, try again\n"));
1132                 goto fail;
1133         }
1134 
1135         ipw2100_master_stop(sc);
1136 
1137         ipw2100_ring_hwsetup(sc);
1138 
1139         /*
1140          * load firmware
1141          */
1142         IPW2100_DBG(IPW2100_DBG_INIT, (sc->sc_dip, CE_CONT,
1143             "ipw2100_init(): loading firmware\n"));
1144         err = ipw2100_load_fw(sc);
1145         if (err != DDI_SUCCESS) {
1146                 IPW2100_WARN((sc->sc_dip, CE_WARN,
1147                     "ipw2100_init(): could not load firmware, try again\n"));
1148                 goto fail;
1149         }
1150 
1151         /*
1152          * initialize tables
1153          */
1154         ipw2100_tables_init(sc);
1155         ipw2100_table1_put32(sc, IPW2100_INFO_LOCK, 0);
1156 
1157         /*
1158          * Hardware will be enabled after configuration
1159          */
1160         err = ipw2100_config(sc);
1161         if (err != DDI_SUCCESS) {
1162                 IPW2100_WARN((sc->sc_dip, CE_WARN,
1163                     "ipw2100_init(): device configuration failed\n"));
1164                 goto fail;
1165         }
1166 
1167         delay(drv_usectohz(delay_config_stable));
1168 
1169         return (DDI_SUCCESS);
1170 
1171 fail:
1172         ipw2100_stop(sc);
1173 
1174         return (err);
1175 }
1176 
1177 /*
1178  * get hardware configurations from EEPROM embedded within chip
1179  */
1180 static void
1181 ipw2100_hwconf_get(struct ipw2100_softc *sc)
1182 {
1183         int             i;
1184         uint16_t        val;
1185 
1186         /*
1187          * MAC address
1188          */
1189         i = 0;
1190         val = ipw2100_rom_get16(sc, IPW2100_ROM_MAC + 0);
1191         sc->sc_macaddr[i++] = val >> 8;
1192         sc->sc_macaddr[i++] = val & 0xff;
1193         val = ipw2100_rom_get16(sc, IPW2100_ROM_MAC + 1);
1194         sc->sc_macaddr[i++] = val >> 8;
1195         sc->sc_macaddr[i++] = val & 0xff;
1196         val = ipw2100_rom_get16(sc, IPW2100_ROM_MAC + 2);
1197         sc->sc_macaddr[i++] = val >> 8;
1198         sc->sc_macaddr[i++] = val & 0xff;
1199 
1200         /*
1201          * formatted MAC address string
1202          */
1203         (void) snprintf(sc->sc_macstr, sizeof (sc->sc_macstr),
1204             "%02x:%02x:%02x:%02x:%02x:%02x",
1205             sc->sc_macaddr[0], sc->sc_macaddr[1],
1206             sc->sc_macaddr[2], sc->sc_macaddr[3],
1207             sc->sc_macaddr[4], sc->sc_macaddr[5]);
1208 
1209         /*
1210          * channel mask
1211          */
1212         val = ipw2100_rom_get16(sc, IPW2100_ROM_CHANNEL_LIST);
1213         if (val == 0)
1214                 val = 0x7ff;
1215         sc->sc_chmask = val << 1;
1216         IPW2100_DBG(IPW2100_DBG_HWCAP, (sc->sc_dip, CE_CONT,
1217             "ipw2100_hwconf_get(): channel-mask=0x%08x\n", sc->sc_chmask));
1218 
1219         /*
1220          * radio switch
1221          */
1222         val = ipw2100_rom_get16(sc, IPW2100_ROM_RADIO);
1223         if (val & 0x08)
1224                 sc->sc_flags |= IPW2100_FLAG_HAS_RADIO_SWITCH;
1225 
1226         IPW2100_DBG(IPW2100_DBG_HWCAP, (sc->sc_dip, CE_CONT,
1227             "ipw2100_hwconf_get(): has-radio-switch=%s(%u)\n",
1228             (sc->sc_flags & IPW2100_FLAG_HAS_RADIO_SWITCH)?  "yes" : "no",
1229             val));
1230 }
1231 
1232 /*
1233  * all ipw2100 interrupts will be masked by this routine
1234  */
1235 static void
1236 ipw2100_master_stop(struct ipw2100_softc *sc)
1237 {
1238         uint32_t        tmp;
1239         int             ntries;
1240 
1241         /*
1242          * disable interrupts
1243          */
1244         ipw2100_csr_put32(sc, IPW2100_CSR_INTR_MASK, 0);
1245 
1246         ipw2100_csr_put32(sc, IPW2100_CSR_RST, IPW2100_RST_STOP_MASTER);
1247         for (ntries = 0; ntries < 50; ntries++) {
1248                 if (ipw2100_csr_get32(sc, IPW2100_CSR_RST)
1249                     & IPW2100_RST_MASTER_DISABLED)
1250                         break;
1251                 drv_usecwait(10);
1252         }
1253         if (ntries == 50 && !(sc->sc_flags & IPW2100_FLAG_QUIESCED))
1254                 IPW2100_WARN((sc->sc_dip, CE_WARN,
1255                     "ipw2100_master_stop(): timeout when stop master\n"));
1256 
1257         tmp = ipw2100_csr_get32(sc, IPW2100_CSR_RST);
1258         ipw2100_csr_put32(sc, IPW2100_CSR_RST,
1259             tmp | IPW2100_RST_PRINCETON_RESET);
1260 
1261         sc->sc_flags &= ~IPW2100_FLAG_FW_INITED;
1262 }
1263 
1264 /*
1265  * all ipw2100 interrupts will be masked by this routine
1266  */
1267 static int
1268 ipw2100_chip_reset(struct ipw2100_softc *sc)
1269 {
1270         int             ntries;
1271         uint32_t        tmp;
1272 
1273         ipw2100_master_stop(sc);
1274 
1275         /*
1276          * move adapter to DO state
1277          */
1278         tmp = ipw2100_csr_get32(sc, IPW2100_CSR_CTL);
1279         ipw2100_csr_put32(sc, IPW2100_CSR_CTL, tmp | IPW2100_CTL_INIT);
1280 
1281         /*
1282          * wait for clock stabilization
1283          */
1284         for (ntries = 0; ntries < 1000; ntries++) {
1285                 if (ipw2100_csr_get32(sc, IPW2100_CSR_CTL)
1286                     & IPW2100_CTL_CLOCK_READY)
1287                         break;
1288                 drv_usecwait(200);
1289         }
1290         if (ntries == 1000)
1291                 return (DDI_FAILURE);
1292 
1293         tmp = ipw2100_csr_get32(sc, IPW2100_CSR_RST);
1294         ipw2100_csr_put32(sc, IPW2100_CSR_RST, tmp | IPW2100_RST_SW_RESET);
1295 
1296         drv_usecwait(10);
1297 
1298         tmp = ipw2100_csr_get32(sc, IPW2100_CSR_CTL);
1299         ipw2100_csr_put32(sc, IPW2100_CSR_CTL, tmp | IPW2100_CTL_INIT);
1300 
1301         return (DDI_SUCCESS);
1302 }
1303 
1304 /*
1305  * get the radio status from IPW_CSR_IO, invoked by wificonfig/dladm
1306  */
1307 int
1308 ipw2100_get_radio(struct ipw2100_softc *sc)
1309 {
1310         if (ipw2100_csr_get32(sc, IPW2100_CSR_IO) & IPW2100_IO_RADIO_DISABLED)
1311                 return (0);
1312         else
1313                 return (1);
1314 
1315 }
1316 /*
1317  * This function is used to get the statistic, invoked by wificonfig/dladm
1318  */
1319 void
1320 ipw2100_get_statistics(struct ipw2100_softc *sc)
1321 {
1322         struct ieee80211com     *ic = &sc->sc_ic;
1323         uint32_t                addr, size, i;
1324         uint32_t                atbl[256], *datatbl;
1325 
1326         datatbl = atbl;
1327 
1328         if (!(sc->sc_flags & IPW2100_FLAG_FW_INITED)) {
1329                 IPW2100_DBG(IPW2100_DBG_STATISTIC, (sc->sc_dip, CE_CONT,
1330                     "ipw2100_get_statistic(): fw doesn't download yet."));
1331                 return;
1332         }
1333 
1334         ipw2100_csr_put32(sc, IPW2100_CSR_AUTOINC_ADDR, sc->sc_table1_base);
1335 
1336         size = ipw2100_csr_get32(sc, IPW2100_CSR_AUTOINC_DATA);
1337         atbl[0] = size;
1338         for (i = 1, ++datatbl; i < size; i++, datatbl++) {
1339                 addr = ipw2100_csr_get32(sc, IPW2100_CSR_AUTOINC_DATA);
1340                 *datatbl = ipw2100_imem_get32(sc, addr);
1341         }
1342 
1343         /*
1344          * To retrieve the statistic information into proper places. There are
1345          * lot of information.
1346          */
1347         IPW2100_DBG(IPW2100_DBG_STATISTIC, (sc->sc_dip, CE_CONT,
1348             "ipw2100_get_statistic(): \n"
1349             "operating mode = %u\n"
1350             "type of authentification= %u\n"
1351             "average RSSI= %u\n"
1352             "current channel = %d\n",
1353             atbl[191], atbl[199], atbl[173], atbl[189]));
1354         /* WIFI_STAT_TX_FRAGS */
1355         ic->ic_stats.is_tx_frags = (uint32_t)atbl[2];
1356         /* WIFI_STAT_MCAST_TX = (all frame - unicast frame) */
1357         ic->ic_stats.is_tx_mcast = (uint32_t)atbl[2] - (uint32_t)atbl[3];
1358         /* WIFI_STAT_TX_RETRANS */
1359         ic->ic_stats.is_tx_retries = (uint32_t)atbl[42];
1360         /* WIFI_STAT_TX_FAILED */
1361         ic->ic_stats.is_tx_failed = (uint32_t)atbl[51];
1362         /* MAC_STAT_OBYTES */
1363         ic->ic_stats.is_tx_bytes = (uint32_t)atbl[41];
1364         /* WIFI_STAT_RX_FRAGS */
1365         ic->ic_stats.is_rx_frags = (uint32_t)atbl[61];
1366         /* WIFI_STAT_MCAST_RX */
1367         ic->ic_stats.is_rx_mcast = (uint32_t)atbl[71];
1368         /* MAC_STAT_IBYTES */
1369         ic->ic_stats.is_rx_bytes = (uint32_t)atbl[101];
1370         /* WIFI_STAT_ACK_FAILURE */
1371         ic->ic_stats.is_ack_failure = (uint32_t)atbl[59];
1372         /* WIFI_STAT_RTS_SUCCESS */
1373         ic->ic_stats.is_rts_success = (uint32_t)atbl[22];
1374 }
1375 
1376 /*
1377  * dma region alloc
1378  */
1379 static int
1380 ipw2100_dma_region_alloc(struct ipw2100_softc *sc,
1381     struct dma_region *dr, size_t size, uint_t dir, uint_t flags)
1382 {
1383         dev_info_t      *dip = sc->sc_dip;
1384         int             err;
1385 
1386         IPW2100_DBG(IPW2100_DBG_DMA, (dip, CE_CONT,
1387             "ipw2100_dma_region_alloc() name=%s size=%u\n",
1388             dr->dr_name, size));
1389 
1390         err = ddi_dma_alloc_handle(dip, &ipw2100_dma_attr, DDI_DMA_SLEEP, NULL,
1391             &dr->dr_hnd);
1392         if (err != DDI_SUCCESS) {
1393                 IPW2100_DBG(IPW2100_DBG_DMA, (dip, CE_CONT,
1394                     "ipw2100_dma_region_alloc(): "
1395                     "ddi_dma_alloc_handle() failed\n"));
1396                 goto fail0;
1397         }
1398 
1399         err = ddi_dma_mem_alloc(dr->dr_hnd, size, &ipw2100_dma_accattr,
1400             flags, DDI_DMA_SLEEP, NULL, &dr->dr_base,
1401             &dr->dr_size, &dr->dr_acc);
1402         if (err != DDI_SUCCESS) {
1403                 IPW2100_DBG(IPW2100_DBG_DMA, (dip, CE_CONT,
1404                     "ipw2100_dma_region_alloc(): "
1405                     "ddi_dma_mem_alloc() failed\n"));
1406                 goto fail1;
1407         }
1408 
1409         err = ddi_dma_addr_bind_handle(dr->dr_hnd, NULL,
1410             dr->dr_base, dr->dr_size, dir | flags, DDI_DMA_SLEEP, NULL,
1411             &dr->dr_cookie, &dr->dr_ccnt);
1412         if (err != DDI_DMA_MAPPED) {
1413                 IPW2100_DBG(IPW2100_DBG_DMA, (dip, CE_CONT,
1414                     "ipw2100_dma_region_alloc(): "
1415                     "ddi_dma_addr_bind_handle() failed\n"));
1416                 goto fail2;
1417         }
1418 
1419         if (dr->dr_ccnt != 1) {
1420                 err = DDI_FAILURE;
1421                 goto fail3;
1422         }
1423         dr->dr_pbase = dr->dr_cookie.dmac_address;
1424 
1425         IPW2100_DBG(IPW2100_DBG_DMA, (dip, CE_CONT,
1426             "ipw2100_dma_region_alloc(): get physical-base=0x%08x\n",
1427             dr->dr_pbase));
1428 
1429         return (DDI_SUCCESS);
1430 
1431 fail3:
1432         (void) ddi_dma_unbind_handle(dr->dr_hnd);
1433 fail2:
1434         ddi_dma_mem_free(&dr->dr_acc);
1435 fail1:
1436         ddi_dma_free_handle(&dr->dr_hnd);
1437 fail0:
1438         return (err);
1439 }
1440 
1441 static void
1442 ipw2100_dma_region_free(struct dma_region *dr)
1443 {
1444         (void) ddi_dma_unbind_handle(dr->dr_hnd);
1445         ddi_dma_mem_free(&dr->dr_acc);
1446         ddi_dma_free_handle(&dr->dr_hnd);
1447 }
1448 
1449 static int
1450 ipw2100_ring_alloc(struct ipw2100_softc *sc)
1451 {
1452         int     err, i;
1453 
1454         /*
1455          * tx ring
1456          */
1457         sc->sc_dma_txbd.dr_name = "ipw2100-tx-ring-bd";
1458         err = ipw2100_dma_region_alloc(sc, &sc->sc_dma_txbd,
1459             IPW2100_TXBD_SIZE, DDI_DMA_WRITE, DDI_DMA_CONSISTENT);
1460         if (err != DDI_SUCCESS)
1461                 goto fail0;
1462         /*
1463          * tx bufs
1464          */
1465         for (i = 0; i < IPW2100_NUM_TXBUF; i++) {
1466                 sc->sc_dma_txbufs[i].dr_name = "ipw2100-tx-buf";
1467                 err = ipw2100_dma_region_alloc(sc, &sc->sc_dma_txbufs[i],
1468                     IPW2100_TXBUF_SIZE, DDI_DMA_WRITE, DDI_DMA_STREAMING);
1469                 if (err != DDI_SUCCESS) {
1470                         while (i > 0) {
1471                                 i--;
1472                                 ipw2100_dma_region_free(&sc->sc_dma_txbufs[i]);
1473                         }
1474                         goto fail1;
1475                 }
1476         }
1477         /*
1478          * rx ring
1479          */
1480         sc->sc_dma_rxbd.dr_name = "ipw2100-rx-ring-bd";
1481         err = ipw2100_dma_region_alloc(sc, &sc->sc_dma_rxbd,
1482             IPW2100_RXBD_SIZE, DDI_DMA_WRITE, DDI_DMA_CONSISTENT);
1483         if (err != DDI_SUCCESS)
1484                 goto fail2;
1485         /*
1486          * rx bufs
1487          */
1488         for (i = 0; i < IPW2100_NUM_RXBUF; i++) {
1489                 sc->sc_dma_rxbufs[i].dr_name = "ipw2100-rx-buf";
1490                 err = ipw2100_dma_region_alloc(sc, &sc->sc_dma_rxbufs[i],
1491                     IPW2100_RXBUF_SIZE, DDI_DMA_READ, DDI_DMA_STREAMING);
1492                 if (err != DDI_SUCCESS) {
1493                         while (i > 0) {
1494                                 i--;
1495                                 ipw2100_dma_region_free(&sc->sc_dma_rxbufs[i]);
1496                         }
1497                         goto fail3;
1498                 }
1499         }
1500         /*
1501          * status
1502          */
1503         sc->sc_dma_status.dr_name = "ipw2100-rx-status";
1504         err = ipw2100_dma_region_alloc(sc, &sc->sc_dma_status,
1505             IPW2100_STATUS_SIZE, DDI_DMA_READ, DDI_DMA_CONSISTENT);
1506         if (err != DDI_SUCCESS)
1507                 goto fail4;
1508         /*
1509          * command
1510          */
1511         sc->sc_dma_cmd.dr_name = "ipw2100-cmd";
1512         err = ipw2100_dma_region_alloc(sc, &sc->sc_dma_cmd, IPW2100_CMD_SIZE,
1513             DDI_DMA_WRITE, DDI_DMA_CONSISTENT);
1514         if (err != DDI_SUCCESS)
1515                 goto fail5;
1516 
1517         return (DDI_SUCCESS);
1518 
1519 fail5:
1520         ipw2100_dma_region_free(&sc->sc_dma_status);
1521 fail4:
1522         for (i = 0; i < IPW2100_NUM_RXBUF; i++)
1523                 ipw2100_dma_region_free(&sc->sc_dma_rxbufs[i]);
1524 fail3:
1525         ipw2100_dma_region_free(&sc->sc_dma_rxbd);
1526 fail2:
1527         for (i = 0; i < IPW2100_NUM_TXBUF; i++)
1528                 ipw2100_dma_region_free(&sc->sc_dma_txbufs[i]);
1529 fail1:
1530         ipw2100_dma_region_free(&sc->sc_dma_txbd);
1531 fail0:
1532         return (err);
1533 }
1534 
1535 static void
1536 ipw2100_ring_free(struct ipw2100_softc *sc)
1537 {
1538         int     i;
1539 
1540         /*
1541          * tx ring
1542          */
1543         ipw2100_dma_region_free(&sc->sc_dma_txbd);
1544         /*
1545          * tx buf
1546          */
1547         for (i = 0; i < IPW2100_NUM_TXBUF; i++)
1548                 ipw2100_dma_region_free(&sc->sc_dma_txbufs[i]);
1549         /*
1550          * rx ring
1551          */
1552         ipw2100_dma_region_free(&sc->sc_dma_rxbd);
1553         /*
1554          * rx buf
1555          */
1556         for (i = 0; i < IPW2100_NUM_RXBUF; i++)
1557                 ipw2100_dma_region_free(&sc->sc_dma_rxbufs[i]);
1558         /*
1559          * status
1560          */
1561         ipw2100_dma_region_free(&sc->sc_dma_status);
1562         /*
1563          * command
1564          */
1565         ipw2100_dma_region_free(&sc->sc_dma_cmd);
1566 }
1567 
1568 static void
1569 ipw2100_ring_reset(struct ipw2100_softc *sc)
1570 {
1571         int     i;
1572 
1573         /*
1574          * tx ring
1575          */
1576         sc->sc_tx_cur   = 0;
1577         sc->sc_tx_free  = IPW2100_NUM_TXBD;
1578         sc->sc_txbd  = (struct ipw2100_bd *)sc->sc_dma_txbd.dr_base;
1579         for (i = 0; i < IPW2100_NUM_TXBUF; i++)
1580                 sc->sc_txbufs[i] =
1581                     (struct ipw2100_txb *)sc->sc_dma_txbufs[i].dr_base;
1582         /*
1583          * rx ring
1584          */
1585         sc->sc_rx_cur   = 0;
1586         sc->sc_rx_free  = IPW2100_NUM_RXBD;
1587         sc->sc_status   = (struct ipw2100_status *)sc->sc_dma_status.dr_base;
1588         sc->sc_rxbd  = (struct ipw2100_bd *)sc->sc_dma_rxbd.dr_base;
1589         for (i = 0; i < IPW2100_NUM_RXBUF; i++) {
1590                 sc->sc_rxbufs[i] =
1591                     (struct ipw2100_rxb *)sc->sc_dma_rxbufs[i].dr_base;
1592                 /*
1593                  * initialize Rx buffer descriptors, both host and device
1594                  */
1595                 sc->sc_rxbd[i].phyaddr  = LE_32(sc->sc_dma_rxbufs[i].dr_pbase);
1596                 sc->sc_rxbd[i].len   = LE_32(sc->sc_dma_rxbufs[i].dr_size);
1597                 sc->sc_rxbd[i].flags = 0;
1598                 sc->sc_rxbd[i].nfrag = 1;
1599         }
1600         /*
1601          * command
1602          */
1603         sc->sc_cmd = (struct ipw2100_cmd *)sc->sc_dma_cmd.dr_base;
1604 }
1605 
1606 /*
1607  * tx, rx rings and command initialization
1608  */
1609 static int
1610 ipw2100_ring_init(struct ipw2100_softc *sc)
1611 {
1612         int     err;
1613 
1614         err = ipw2100_ring_alloc(sc);
1615         if (err != DDI_SUCCESS)
1616                 return (err);
1617 
1618         ipw2100_ring_reset(sc);
1619 
1620         return (DDI_SUCCESS);
1621 }
1622 
1623 static void
1624 ipw2100_ring_hwsetup(struct ipw2100_softc *sc)
1625 {
1626         ipw2100_ring_reset(sc);
1627         /*
1628          * tx ring
1629          */
1630         ipw2100_csr_put32(sc, IPW2100_CSR_TX_BD_BASE, sc->sc_dma_txbd.dr_pbase);
1631         ipw2100_csr_put32(sc, IPW2100_CSR_TX_BD_SIZE, IPW2100_NUM_TXBD);
1632         /*
1633          * no new packet to transmit, tx-rd-index == tx-wr-index
1634          */
1635         ipw2100_csr_put32(sc, IPW2100_CSR_TX_READ_INDEX, sc->sc_tx_cur);
1636         ipw2100_csr_put32(sc, IPW2100_CSR_TX_WRITE_INDEX, sc->sc_tx_cur);
1637         /*
1638          * rx ring
1639          */
1640         ipw2100_csr_put32(sc, IPW2100_CSR_RX_BD_BASE, sc->sc_dma_rxbd.dr_pbase);
1641         ipw2100_csr_put32(sc, IPW2100_CSR_RX_BD_SIZE, IPW2100_NUM_RXBD);
1642         /*
1643          * all rx buffer are empty, rx-rd-index == 0 && rx-wr-index == N-1
1644          */
1645         IPW2100_DBG(IPW2100_DBG_RING, (sc->sc_dip, CE_CONT,
1646             "ipw2100_ring_hwsetup(): rx-cur=%u, backward=%u\n",
1647             sc->sc_rx_cur, RING_BACKWARD(sc->sc_rx_cur, 1, IPW2100_NUM_RXBD)));
1648         ipw2100_csr_put32(sc, IPW2100_CSR_RX_READ_INDEX, sc->sc_rx_cur);
1649         ipw2100_csr_put32(sc, IPW2100_CSR_RX_WRITE_INDEX,
1650             RING_BACKWARD(sc->sc_rx_cur, 1, IPW2100_NUM_RXBD));
1651         /*
1652          * status
1653          */
1654         ipw2100_csr_put32(sc, IPW2100_CSR_RX_STATUS_BASE,
1655             sc->sc_dma_status.dr_pbase);
1656 }
1657 
1658 /*
1659  * ieee80211_new_state() is not be used, since the hardware can handle the
1660  * state transfer. Here, we just keep the status of the hardware notification
1661  * result.
1662  */
1663 /* ARGSUSED */
1664 static int
1665 ipw2100_newstate(struct ieee80211com *ic, enum ieee80211_state state, int arg)
1666 {
1667         struct ipw2100_softc    *sc = (struct ipw2100_softc *)ic;
1668         struct ieee80211_node   *in;
1669         uint8_t                 macaddr[IEEE80211_ADDR_LEN];
1670         uint32_t                len;
1671         wifi_data_t             wd = { 0 };
1672 
1673         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
1674             "ipw2100_newstate(): %s -> %s\n",
1675             ieee80211_state_name[ic->ic_state], ieee80211_state_name[state]));
1676 
1677         switch (state) {
1678         case IEEE80211_S_RUN:
1679                 /*
1680                  * we only need to use BSSID as to find the node
1681                  */
1682                 drv_usecwait(200); /* firmware needs a short delay here */
1683                 len = IEEE80211_ADDR_LEN;
1684                 (void) ipw2100_table2_getbuf(sc, IPW2100_INFO_CURRENT_BSSID,
1685                     macaddr, &len);
1686 
1687                 in = ieee80211_find_node(&ic->ic_scan, macaddr);
1688                 if (in == NULL)
1689                         break;
1690 
1691                 (void) ieee80211_sta_join(ic, in);
1692                 ieee80211_node_authorize(in);
1693 
1694                 /*
1695                  * We can send data now; update the fastpath with our
1696                  * current associated BSSID.
1697                  */
1698                 if (ic->ic_flags & IEEE80211_F_PRIVACY)
1699                         wd.wd_secalloc = WIFI_SEC_WEP;
1700                 else
1701                         wd.wd_secalloc = WIFI_SEC_NONE;
1702                 wd.wd_opmode = ic->ic_opmode;
1703                 IEEE80211_ADDR_COPY(wd.wd_bssid, ic->ic_bss->in_bssid);
1704                 (void) mac_pdata_update(ic->ic_mach, &wd, sizeof (wd));
1705 
1706                 break;
1707 
1708         case IEEE80211_S_INIT:
1709         case IEEE80211_S_SCAN:
1710         case IEEE80211_S_AUTH:
1711         case IEEE80211_S_ASSOC:
1712                 break;
1713         }
1714 
1715         /*
1716          * notify to update the link
1717          */
1718         if ((ic->ic_state != IEEE80211_S_RUN) && (state == IEEE80211_S_RUN)) {
1719                 /*
1720                  * previously disconnected and now connected
1721                  */
1722                 sc->sc_linkstate = LINK_STATE_UP;
1723                 sc->sc_flags |= IPW2100_FLAG_LINK_CHANGE;
1724         } else if ((ic->ic_state == IEEE80211_S_RUN) &&
1725             (state != IEEE80211_S_RUN)) {
1726                 /*
1727                  * previously connected andd now disconnected
1728                  */
1729                 sc->sc_linkstate = LINK_STATE_DOWN;
1730                 sc->sc_flags |= IPW2100_FLAG_LINK_CHANGE;
1731         }
1732 
1733         ic->ic_state = state;
1734         return (DDI_SUCCESS);
1735 }
1736 
1737 /*
1738  * GLD operations
1739  */
1740 /* ARGSUSED */
1741 static int
1742 ipw2100_m_stat(void *arg, uint_t stat, uint64_t *val)
1743 {
1744         ieee80211com_t  *ic = (ieee80211com_t *)arg;
1745         IPW2100_DBG(IPW2100_DBG_GLD, (((struct ipw2100_softc *)arg)->sc_dip,
1746             CE_CONT,
1747             "ipw2100_m_stat(): enter\n"));
1748         /*
1749          * some of below statistic data are from hardware, some from net80211
1750          */
1751         switch (stat) {
1752         case MAC_STAT_RBYTES:
1753                 *val = ic->ic_stats.is_rx_bytes;
1754                 break;
1755         case MAC_STAT_IPACKETS:
1756                 *val = ic->ic_stats.is_rx_frags;
1757                 break;
1758         case MAC_STAT_OBYTES:
1759                 *val = ic->ic_stats.is_tx_bytes;
1760                 break;
1761         case MAC_STAT_OPACKETS:
1762                 *val = ic->ic_stats.is_tx_frags;
1763                 break;
1764         /*
1765          * Get below from hardware statistic, retrieve net80211 value once 1s
1766          */
1767         case WIFI_STAT_TX_FRAGS:
1768         case WIFI_STAT_MCAST_TX:
1769         case WIFI_STAT_TX_FAILED:
1770         case WIFI_STAT_TX_RETRANS:
1771         case WIFI_STAT_RTS_SUCCESS:
1772         case WIFI_STAT_ACK_FAILURE:
1773         case WIFI_STAT_RX_FRAGS:
1774         case WIFI_STAT_MCAST_RX:
1775         /*
1776          * Get blow information from net80211
1777          */
1778         case WIFI_STAT_RTS_FAILURE:
1779         case WIFI_STAT_RX_DUPS:
1780         case WIFI_STAT_FCS_ERRORS:
1781         case WIFI_STAT_WEP_ERRORS:
1782                 return (ieee80211_stat(ic, stat, val));
1783         /*
1784          * need be supported in the future
1785          */
1786         case MAC_STAT_IFSPEED:
1787         case MAC_STAT_NOXMTBUF:
1788         case MAC_STAT_IERRORS:
1789         case MAC_STAT_OERRORS:
1790         default:
1791                 return (ENOTSUP);
1792         }
1793         return (0);
1794 }
1795 
1796 /* ARGSUSED */
1797 static int
1798 ipw2100_m_multicst(void *arg, boolean_t add, const uint8_t *mca)
1799 {
1800         /* not supported */
1801         IPW2100_DBG(IPW2100_DBG_GLD, (((struct ipw2100_softc *)arg)->sc_dip,
1802             CE_CONT,
1803             "ipw2100_m_multicst(): enter\n"));
1804 
1805         return (0);
1806 }
1807 
1808 /*
1809  * This thread function is used to handle the fatal error.
1810  */
1811 static void
1812 ipw2100_thread(struct ipw2100_softc *sc)
1813 {
1814         struct ieee80211com     *ic = &sc->sc_ic;
1815         int32_t                 nlstate;
1816         int                     stat_cnt = 0;
1817 
1818         IPW2100_DBG(IPW2100_DBG_SOFTINT, (sc->sc_dip, CE_CONT,
1819             "ipw2100_thread(): into ipw2100 thread--> %d\n",
1820             sc->sc_linkstate));
1821 
1822         mutex_enter(&sc->sc_mflock);
1823 
1824         while (sc->sc_mfthread_switch) {
1825                 /*
1826                  * notify the link state
1827                  */
1828                 if (ic->ic_mach && (sc->sc_flags & IPW2100_FLAG_LINK_CHANGE)) {
1829                         IPW2100_DBG(IPW2100_DBG_SOFTINT, (sc->sc_dip, CE_CONT,
1830                             "ipw2100_thread(): link status --> %d\n",
1831                             sc->sc_linkstate));
1832 
1833                         sc->sc_flags &= ~IPW2100_FLAG_LINK_CHANGE;
1834                         nlstate = sc->sc_linkstate;
1835 
1836                         mutex_exit(&sc->sc_mflock);
1837                         mac_link_update(ic->ic_mach, nlstate);
1838                         mutex_enter(&sc->sc_mflock);
1839                 }
1840 
1841                 /*
1842                  * recovery interrupt fatal error
1843                  */
1844                 if (ic->ic_mach &&
1845                     (sc->sc_flags & IPW2100_FLAG_HW_ERR_RECOVER)) {
1846 
1847                         IPW2100_DBG(IPW2100_DBG_FATAL, (sc->sc_dip, CE_CONT,
1848                             "try to recover fatal hw error\n"));
1849                         sc->sc_flags &= ~IPW2100_FLAG_HW_ERR_RECOVER;
1850 
1851                         mutex_exit(&sc->sc_mflock);
1852                         (void) ipw2100_init(sc); /* Force stat machine */
1853                         delay(drv_usectohz(delay_fatal_recover));
1854                         mutex_enter(&sc->sc_mflock);
1855                 }
1856 
1857                 /*
1858                  * get statistic, the value will be retrieved by m_stat
1859                  */
1860                 if (stat_cnt == 10) {
1861                         stat_cnt = 0; /* re-start */
1862 
1863                         mutex_exit(&sc->sc_mflock);
1864                         ipw2100_get_statistics(sc);
1865                         mutex_enter(&sc->sc_mflock);
1866                 } else
1867                         stat_cnt++; /* until 1s */
1868 
1869                 mutex_exit(&sc->sc_mflock);
1870                 delay(drv_usectohz(delay_aux_thread));
1871                 mutex_enter(&sc->sc_mflock);
1872         }
1873         sc->sc_mf_thread = NULL;
1874         cv_broadcast(&sc->sc_mfthread_cv);
1875         mutex_exit(&sc->sc_mflock);
1876 }
1877 
1878 static int
1879 ipw2100_m_start(void *arg)
1880 {
1881         struct ipw2100_softc    *sc = (struct ipw2100_softc *)arg;
1882 
1883         IPW2100_DBG(IPW2100_DBG_GLD, (sc->sc_dip, CE_CONT,
1884             "ipw2100_m_start(): enter\n"));
1885 
1886         /*
1887          * initialize ipw2100 hardware
1888          */
1889         (void) ipw2100_init(sc);
1890 
1891         sc->sc_flags |= IPW2100_FLAG_RUNNING;
1892         /*
1893          * fix KCF bug. - workaround, need to fix it in net80211
1894          */
1895         (void) crypto_mech2id(SUN_CKM_RC4);
1896 
1897         return (0);
1898 }
1899 
1900 static void
1901 ipw2100_m_stop(void *arg)
1902 {
1903         struct ipw2100_softc    *sc = (struct ipw2100_softc *)arg;
1904 
1905         IPW2100_DBG(IPW2100_DBG_GLD, (sc->sc_dip, CE_CONT,
1906             "ipw2100_m_stop(): enter\n"));
1907 
1908         ipw2100_stop(sc);
1909 
1910         sc->sc_flags &= ~IPW2100_FLAG_RUNNING;
1911 }
1912 
1913 static int
1914 ipw2100_m_unicst(void *arg, const uint8_t *macaddr)
1915 {
1916         struct ipw2100_softc    *sc = (struct ipw2100_softc *)arg;
1917         struct ieee80211com     *ic = &sc->sc_ic;
1918         int                     err;
1919 
1920         IPW2100_DBG(IPW2100_DBG_GLD, (sc->sc_dip, CE_CONT,
1921             "ipw2100_m_unicst(): enter\n"));
1922 
1923         IPW2100_DBG(IPW2100_DBG_GLD, (sc->sc_dip, CE_CONT,
1924             "ipw2100_m_unicst(): GLD setting MAC address to "
1925             "%02x:%02x:%02x:%02x:%02x:%02x\n",
1926             macaddr[0], macaddr[1], macaddr[2],
1927             macaddr[3], macaddr[4], macaddr[5]));
1928 
1929         if (!IEEE80211_ADDR_EQ(ic->ic_macaddr, macaddr)) {
1930                 IEEE80211_ADDR_COPY(ic->ic_macaddr, macaddr);
1931 
1932                 if (sc->sc_flags & IPW2100_FLAG_RUNNING) {
1933                         err = ipw2100_config(sc);
1934                         if (err != DDI_SUCCESS) {
1935                                 IPW2100_WARN((sc->sc_dip, CE_WARN,
1936                                     "ipw2100_m_unicst(): "
1937                                     "device configuration failed\n"));
1938                                 goto fail;
1939                         }
1940                 }
1941         }
1942 
1943         return (0);
1944 fail:
1945         return (EIO);
1946 }
1947 
1948 static int
1949 ipw2100_m_promisc(void *arg, boolean_t on)
1950 {
1951         struct ipw2100_softc    *sc = (struct ipw2100_softc *)arg;
1952         int recfg, err;
1953 
1954         IPW2100_DBG(IPW2100_DBG_GLD, (sc->sc_dip, CE_CONT,
1955             "ipw2100_m_promisc(): enter. "
1956             "GLD setting promiscuous mode - %d\n", on));
1957 
1958         recfg = 0;
1959         if (on)
1960                 if (!(sc->if_flags & IFF_PROMISC)) {
1961                         sc->if_flags |= IFF_PROMISC;
1962                         recfg = 1;
1963                 }
1964         else
1965                 if (sc->if_flags & IFF_PROMISC) {
1966                         sc->if_flags &= ~IFF_PROMISC;
1967                         recfg = 1;
1968                 }
1969 
1970         if (recfg && (sc->sc_flags & IPW2100_FLAG_RUNNING)) {
1971                 err = ipw2100_config(sc);
1972                 if (err != DDI_SUCCESS) {
1973                         IPW2100_WARN((sc->sc_dip, CE_WARN,
1974                             "ipw2100_m_promisc(): "
1975                             "device configuration failed\n"));
1976                         goto fail;
1977                 }
1978         }
1979 
1980         return (0);
1981 fail:
1982         return (EIO);
1983 }
1984 
1985 static mblk_t *
1986 ipw2100_m_tx(void *arg, mblk_t *mp)
1987 {
1988         struct ipw2100_softc    *sc = (struct ipw2100_softc *)arg;
1989         struct ieee80211com     *ic = &sc->sc_ic;
1990         mblk_t                  *next;
1991 
1992         /*
1993          * No data frames go out unless we're associated; this
1994          * should not happen as the 802.11 layer does not enable
1995          * the xmit queue until we enter the RUN state.
1996          */
1997         if (ic->ic_state != IEEE80211_S_RUN) {
1998                 IPW2100_DBG(IPW2100_DBG_GLD, (sc->sc_dip, CE_CONT,
1999                     "ipw2100_m_tx(): discard msg, ic_state = %u\n",
2000                     ic->ic_state));
2001                 freemsgchain(mp);
2002                 return (NULL);
2003         }
2004 
2005         while (mp != NULL) {
2006                 next = mp->b_next;
2007                 mp->b_next = NULL;
2008                 if (ipw2100_send(ic, mp, IEEE80211_FC0_TYPE_DATA) !=
2009                     DDI_SUCCESS) {
2010                         mp->b_next = next;
2011                         break;
2012                 }
2013                 mp = next;
2014         }
2015         return (mp);
2016 }
2017 
2018 /* ARGSUSED */
2019 static int
2020 ipw2100_send(ieee80211com_t *ic, mblk_t *mp, uint8_t type)
2021 {
2022         struct ipw2100_softc    *sc = (struct ipw2100_softc *)ic;
2023         struct ieee80211_node   *in;
2024         struct ieee80211_frame  wh, *wh_tmp;
2025         struct ieee80211_key    *k;
2026         uint8_t                 *hdat;
2027         mblk_t                  *m0, *m;
2028         size_t                  cnt, off;
2029         struct ipw2100_bd       *txbd[2];
2030         struct ipw2100_txb      *txbuf;
2031         struct dma_region       *dr;
2032         struct ipw2100_hdr      *h;
2033         uint32_t                idx, bidx;
2034         int                     err;
2035 
2036         ASSERT(mp->b_next == NULL);
2037 
2038         m0 = NULL;
2039         m = NULL;
2040         err = DDI_SUCCESS;
2041 
2042         IPW2100_DBG(IPW2100_DBG_GLD, (sc->sc_dip, CE_CONT,
2043             "ipw2100_send(): enter\n"));
2044 
2045         if ((type & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_DATA) {
2046                 /*
2047                  * it is impossible to send non-data 802.11 frame in current
2048                  * ipw driver. Therefore, drop the package
2049                  */
2050                 freemsg(mp);
2051                 err = DDI_SUCCESS;
2052                 goto fail0;
2053         }
2054 
2055         mutex_enter(&sc->sc_tx_lock);
2056 
2057         /*
2058          * need 2 descriptors: 1 for SEND cmd parameter header,
2059          * and the other for payload, i.e., 802.11 frame including 802.11
2060          * frame header
2061          */
2062         if (sc->sc_tx_free < 2) {
2063                 mutex_enter(&sc->sc_resched_lock);
2064                 IPW2100_DBG(IPW2100_DBG_RING, (sc->sc_dip, CE_WARN,
2065                     "ipw2100_send(): no enough descriptors(%d)\n",
2066                     sc->sc_tx_free));
2067                 ic->ic_stats.is_tx_nobuf++; /* no enough buffer */
2068                 sc->sc_flags |= IPW2100_FLAG_TX_SCHED;
2069                 err = DDI_FAILURE;
2070                 mutex_exit(&sc->sc_resched_lock);
2071                 goto fail1;
2072         }
2073         IPW2100_DBG(IPW2100_DBG_RING, (sc->sc_dip, CE_CONT,
2074             "ipw2100_send(): tx-free=%d,tx-curr=%d\n",
2075             sc->sc_tx_free, sc->sc_tx_cur));
2076 
2077         wh_tmp = (struct ieee80211_frame *)mp->b_rptr;
2078         in = ieee80211_find_txnode(ic, wh_tmp->i_addr1);
2079         if (in == NULL) { /* can not find tx node, drop the package */
2080                 freemsg(mp);
2081                 err = DDI_SUCCESS;
2082                 goto fail1;
2083         }
2084         in->in_inact = 0;
2085         (void) ieee80211_encap(ic, mp, in);
2086         ieee80211_free_node(in);
2087 
2088         if (wh_tmp->i_fc[1] & IEEE80211_FC1_WEP) {
2089                 /*
2090                  * it is very bad that ieee80211_crypto_encap can only accept a
2091                  * single continuous buffer.
2092                  */
2093                 /*
2094                  * allocate 32 more bytes is to be compatible with further
2095                  * ieee802.11i standard.
2096                  */
2097                 m = allocb(msgdsize(mp) + 32, BPRI_MED);
2098                 if (m == NULL) { /* can not alloc buf, drop this package */
2099                         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
2100                             "ipw2100_send(): msg allocation failed\n"));
2101 
2102                         freemsg(mp);
2103 
2104                         err = DDI_SUCCESS;
2105                         goto fail1;
2106                 }
2107                 off = 0;
2108                 m0 = mp;
2109                 while (m0) {
2110                         cnt = MBLKL(m0);
2111                         if (cnt) {
2112                                 (void) memcpy(m->b_rptr + off, m0->b_rptr, cnt);
2113                                 off += cnt;
2114                         }
2115                         m0 = m0->b_cont;
2116                 }
2117                 m->b_wptr += off;
2118                 IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
2119                     "ipw2100_send(): "
2120                     "Encrypting 802.11 frame started, %d, %d\n",
2121                     msgdsize(mp), MBLKL(mp)));
2122                 k = ieee80211_crypto_encap(ic, m);
2123                 if (k == NULL) { /* can not get the key, drop packages */
2124                         IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
2125                             "ipw2100_send(): "
2126                             "Encrypting 802.11 frame failed\n"));
2127 
2128                         freemsg(mp);
2129                         err = DDI_SUCCESS;
2130                         goto fail2;
2131                 }
2132                 IPW2100_DBG(IPW2100_DBG_WIFI, (sc->sc_dip, CE_CONT,
2133                     "ipw2100_send(): "
2134                     "Encrypting 802.11 frame finished, %d, %d, k=0x%08x\n",
2135                     msgdsize(mp), MBLKL(mp), k->wk_flags));
2136         }
2137 
2138         /*
2139          * header descriptor
2140          */
2141         idx = sc->sc_tx_cur;
2142         txbd[0]  = &sc->sc_txbd[idx];
2143         if ((idx & 1) == 0)
2144                 bidx = idx / 2;
2145         sc->sc_tx_cur = RING_FORWARD(sc->sc_tx_cur, 1, IPW2100_NUM_TXBD);
2146         sc->sc_tx_free--;
2147 
2148         /*
2149          * payload descriptor
2150          */
2151         idx = sc->sc_tx_cur;
2152         txbd[1]  = &sc->sc_txbd[idx];
2153         if ((idx & 1) == 0)
2154                 bidx = idx / 2;
2155         sc->sc_tx_cur = RING_FORWARD(sc->sc_tx_cur, 1, IPW2100_NUM_TXBD);
2156         sc->sc_tx_free--;
2157 
2158         /*
2159          * one buffer, SEND cmd header and payload buffer
2160          */
2161         txbuf = sc->sc_txbufs[bidx];
2162         dr = &sc->sc_dma_txbufs[bidx];
2163 
2164         /*
2165          * extract 802.11 header from message, fill wh from m0
2166          */
2167         hdat = (uint8_t *)&wh;
2168         off = 0;
2169         if (m)
2170                 m0 = m;
2171         else
2172                 m0 = mp;
2173         while (off < sizeof (wh)) {
2174                 cnt = MBLKL(m0);
2175                 if (cnt > (sizeof (wh) - off))
2176                         cnt = sizeof (wh) - off;
2177                 if (cnt) {
2178                         (void) memcpy(hdat + off, m0->b_rptr, cnt);
2179                         off += cnt;
2180                         m0->b_rptr += cnt;
2181                 }
2182                 else
2183                         m0 = m0->b_cont;
2184         }
2185 
2186         /*
2187          * prepare SEND cmd header
2188          */
2189         h               = &txbuf->txb_hdr;
2190         h->type              = LE_32(IPW2100_CMD_SEND);
2191         h->subtype   = LE_32(0);
2192         h->encrypted    = ic->ic_flags & IEEE80211_F_PRIVACY ? 1 : 0;
2193         h->encrypt   = 0;
2194         h->keyidx    = 0;
2195         h->keysz     = 0;
2196         h->fragsz    = LE_16(0);
2197         IEEE80211_ADDR_COPY(h->saddr, wh.i_addr2);
2198         if (ic->ic_opmode == IEEE80211_M_STA)
2199                 IEEE80211_ADDR_COPY(h->daddr, wh.i_addr3);
2200         else
2201                 IEEE80211_ADDR_COPY(h->daddr, wh.i_addr1);
2202 
2203         /*
2204          * extract payload from message into tx data buffer
2205          */
2206         off = 0;
2207         while (m0) {
2208                 cnt = MBLKL(m0);
2209                 if (cnt) {
2210                         (void) memcpy(&txbuf->txb_dat[off], m0->b_rptr, cnt);
2211                         off += cnt;
2212                 }
2213                 m0 = m0->b_cont;
2214         }
2215 
2216         /*
2217          * fill SEND cmd header descriptor
2218          */
2219         txbd[0]->phyaddr = LE_32(dr->dr_pbase +
2220             OFFSETOF(struct ipw2100_txb, txb_hdr));
2221         txbd[0]->len = LE_32(sizeof (struct ipw2100_hdr));
2222         txbd[0]->flags       = IPW2100_BD_FLAG_TX_FRAME_802_3 |
2223             IPW2100_BD_FLAG_TX_NOT_LAST_FRAGMENT;
2224         txbd[0]->nfrag       = 2;
2225         /*
2226          * fill payload descriptor
2227          */
2228         txbd[1]->phyaddr = LE_32(dr->dr_pbase +
2229             OFFSETOF(struct ipw2100_txb, txb_dat[0]));
2230         txbd[1]->len = LE_32(off);
2231         txbd[1]->flags       = IPW2100_BD_FLAG_TX_FRAME_802_3 |
2232             IPW2100_BD_FLAG_TX_LAST_FRAGMENT;
2233         txbd[1]->nfrag       = 0;
2234 
2235         /*
2236          * dma sync
2237          */
2238         (void) ddi_dma_sync(dr->dr_hnd, 0, sizeof (struct ipw2100_txb),
2239             DDI_DMA_SYNC_FORDEV);
2240         (void) ddi_dma_sync(sc->sc_dma_txbd.dr_hnd,
2241             (txbd[0] - sc->sc_txbd) * sizeof (struct ipw2100_bd),
2242             sizeof (struct ipw2100_bd), DDI_DMA_SYNC_FORDEV);
2243         /*
2244          * since txbd[1] may not be successive to txbd[0] due to the ring
2245          * organization, another dma_sync is needed to simplify the logic
2246          */
2247         (void) ddi_dma_sync(sc->sc_dma_txbd.dr_hnd,
2248             (txbd[1] - sc->sc_txbd) * sizeof (struct ipw2100_bd),
2249             sizeof (struct ipw2100_bd), DDI_DMA_SYNC_FORDEV);
2250         /*
2251          * update txcur
2252          */
2253         ipw2100_csr_put32(sc, IPW2100_CSR_TX_WRITE_INDEX, sc->sc_tx_cur);
2254 
2255         if (mp) /* success, free the original message */
2256                 freemsg(mp);
2257 fail2:
2258         if (m)
2259                 freemsg(m);
2260 fail1:
2261         mutex_exit(&sc->sc_tx_lock);
2262 fail0:
2263         IPW2100_DBG(IPW2100_DBG_GLD, (sc->sc_dip, CE_CONT,
2264             "ipw2100_send(): exit - err=%d\n", err));
2265 
2266         return (err);
2267 }
2268 
2269 /*
2270  * IOCTL Handler
2271  */
2272 #define IEEE80211_IOCTL_REQUIRED        (1)
2273 #define IEEE80211_IOCTL_NOT_REQUIRED    (0)
2274 static void
2275 ipw2100_m_ioctl(void *arg, queue_t *q, mblk_t *m)
2276 {
2277         struct ipw2100_softc    *sc  = (struct ipw2100_softc *)arg;
2278         struct ieee80211com     *ic = &sc->sc_ic;
2279         int                     err;
2280 
2281         IPW2100_DBG(IPW2100_DBG_GLD, (sc->sc_dip, CE_CONT,
2282             "ipw2100_m_ioctl(): enter\n"));
2283 
2284         /*
2285          * check whether or not need to handle this in net80211
2286          */
2287         if (ipw2100_ioctl(sc, q, m) == IEEE80211_IOCTL_NOT_REQUIRED)
2288                 return; /* succes or fail */
2289 
2290         err = ieee80211_ioctl(ic, q, m);
2291         if (err == ENETRESET) {
2292                 if (sc->sc_flags & IPW2100_FLAG_RUNNING) {
2293                         (void) ipw2100_m_start(sc);
2294                         (void) ieee80211_new_state(ic,
2295                             IEEE80211_S_SCAN, -1);
2296                 }
2297         }
2298         if (err == ERESTART) {
2299                 if (sc->sc_flags & IPW2100_FLAG_RUNNING)
2300                         (void) ipw2100_chip_reset(sc);
2301         }
2302 }
2303 
2304 static int
2305 ipw2100_ioctl(struct ipw2100_softc *sc, queue_t *q, mblk_t *m)
2306 {
2307         struct iocblk   *iocp;
2308         uint32_t        len, ret, cmd;
2309         mblk_t          *m0;
2310         boolean_t       need_privilege;
2311         boolean_t       need_net80211;
2312 
2313         if (MBLKL(m) < sizeof (struct iocblk)) {
2314                 IPW2100_DBG(IPW2100_DBG_IOCTL, (sc->sc_dip, CE_CONT,
2315                     "ipw2100_ioctl(): ioctl buffer too short, %u\n",
2316                     MBLKL(m)));
2317                 miocnak(q, m, 0, EINVAL);
2318                 return (IEEE80211_IOCTL_NOT_REQUIRED);
2319         }
2320 
2321         /*
2322          * Validate the command
2323          */
2324         iocp = (struct iocblk *)(uintptr_t)m->b_rptr;
2325         iocp->ioc_error = 0;
2326         cmd = iocp->ioc_cmd;
2327         need_privilege = B_TRUE;
2328         switch (cmd) {
2329         case WLAN_SET_PARAM:
2330         case WLAN_COMMAND:
2331                 break;
2332         case WLAN_GET_PARAM:
2333                 need_privilege = B_FALSE;
2334                 break;
2335         default:
2336                 IPW2100_DBG(IPW2100_DBG_IOCTL, (sc->sc_dip, CE_CONT,
2337                     "ieee80211_ioctl(): unknown cmd 0x%x", cmd));
2338                 miocnak(q, m, 0, EINVAL);
2339                 return (IEEE80211_IOCTL_NOT_REQUIRED);
2340         }
2341 
2342         if (need_privilege && (ret = secpolicy_dl_config(iocp->ioc_cr)) != 0) {
2343                 miocnak(q, m, 0, ret);
2344                 return (IEEE80211_IOCTL_NOT_REQUIRED);
2345         }
2346 
2347         /*
2348          * sanity check
2349          */
2350         m0 = m->b_cont;
2351         if (iocp->ioc_count == 0 || iocp->ioc_count < sizeof (wldp_t) ||
2352             m0 == NULL) {
2353                 miocnak(q, m, 0, EINVAL);
2354                 return (IEEE80211_IOCTL_NOT_REQUIRED);
2355         }
2356         /*
2357          * assuming single data block
2358          */
2359         if (m0->b_cont) {
2360                 freemsg(m0->b_cont);
2361                 m0->b_cont = NULL;
2362         }
2363 
2364         need_net80211 = B_FALSE;
2365         ret = ipw2100_getset(sc, m0, cmd, &need_net80211);
2366         if (!need_net80211) {
2367                 len = msgdsize(m0);
2368 
2369                 IPW2100_DBG(IPW2100_DBG_IOCTL, (sc->sc_dip, CE_CONT,
2370                     "ipw2100_ioctl(): go to call miocack with "
2371                     "ret = %d, len = %d\n", ret, len));
2372                 miocack(q, m, len, ret);
2373                 return (IEEE80211_IOCTL_NOT_REQUIRED);
2374         }
2375 
2376         /*
2377          * IEEE80211_IOCTL_REQUIRED - need net80211 handle
2378          */
2379         return (IEEE80211_IOCTL_REQUIRED);
2380 }
2381 
2382 static int
2383 ipw2100_getset(struct ipw2100_softc *sc, mblk_t *m, uint32_t cmd,
2384         boolean_t *need_net80211)
2385 {
2386         wldp_t          *infp, *outfp;
2387         uint32_t        id;
2388         int             ret; /* IEEE80211_IOCTL - handled by net80211 */
2389 
2390         infp  = (wldp_t *)(uintptr_t)m->b_rptr;
2391         outfp = (wldp_t *)(uintptr_t)m->b_rptr;
2392         outfp->wldp_result = WL_NOTSUPPORTED;
2393 
2394         id = infp->wldp_id;
2395         IPW2100_DBG(IPW2100_DBG_IOCTL, (sc->sc_dip, CE_CONT,
2396             "ipw2100_getset(): id = 0x%x\n", id));
2397         switch (id) {
2398         /*
2399          * which is not supported by net80211, so it
2400          * has to be handled from driver side
2401          */
2402         case WL_RADIO:
2403                 ret = ipw_wificfg_radio(sc, cmd, outfp);
2404                 break;
2405         /*
2406          * so far, drier doesn't support fix-rates
2407          */
2408         case WL_DESIRED_RATES:
2409                 ret = ipw_wificfg_desrates(outfp);
2410                 break;
2411         /*
2412          * current net80211 implementation clears the bssid while
2413          * this command received, which will result in the all zero
2414          * mac address for scan'ed AP which is just disconnected.
2415          * This is a workaround solution until net80211 find a
2416          * better method.
2417          */
2418         case WL_DISASSOCIATE:
2419                 ret = ipw_wificfg_disassoc(sc, outfp);
2420                 break;
2421         default:
2422                 /*
2423                  * The wifi IOCTL net80211 supported:
2424                  *      case WL_ESSID:
2425                  *      case WL_BSSID:
2426                  *      case WL_WEP_KEY_TAB:
2427                  *      case WL_WEP_KEY_ID:
2428                  *      case WL_AUTH_MODE:
2429                  *      case WL_ENCRYPTION:
2430                  *      case WL_BSS_TYPE:
2431                  *      case WL_ESS_LIST:
2432                  *      case WL_LINKSTATUS:
2433                  *      case WL_RSSI:
2434                  *      case WL_SCAN:
2435                  *      case WL_LOAD_DEFAULTS:
2436                  */
2437 
2438                 /*
2439                  * When radio is off, need to ignore all ioctl.  What need to
2440                  * do is to check radio status firstly.  If radio is ON, pass
2441                  * it to net80211, otherwise, return to upper layer directly.
2442                  *
2443                  * Considering the WL_SUCCESS also means WL_CONNECTED for
2444                  * checking linkstatus, one exception for WL_LINKSTATUS is to
2445                  * let net80211 handle it.
2446                  */
2447                 if ((ipw2100_get_radio(sc) == 0) &&
2448                     (id != WL_LINKSTATUS)) {
2449 
2450                         IPW2100_REPORT((sc->sc_dip, CE_WARN,
2451                             "ipw: RADIO is OFF\n"));
2452 
2453                         outfp->wldp_length = WIFI_BUF_OFFSET;
2454                         outfp->wldp_result = WL_SUCCESS;
2455                         ret = 0;
2456                         break;
2457                 }
2458 
2459                 *need_net80211 = B_TRUE; /* let net80211 do the rest */
2460                 return (0);
2461         }
2462         /*
2463          * we will overwrite everything
2464          */
2465         m->b_wptr = m->b_rptr + outfp->wldp_length;
2466 
2467         return (ret);
2468 }
2469 
2470 /*
2471  * Call back functions for get/set proporty
2472  */
2473 static int
2474 ipw2100_m_getprop(void *arg, const char *pr_name, mac_prop_id_t wldp_pr_num,
2475     uint_t wldp_length, void *wldp_buf)
2476 {
2477         struct ipw2100_softc    *sc = (struct ipw2100_softc *)arg;
2478         struct ieee80211com     *ic = &sc->sc_ic;
2479         int                     err = 0;
2480 
2481         switch (wldp_pr_num) {
2482         /* mac_prop_id */
2483         case MAC_PROP_WL_DESIRED_RATES:
2484                 IPW2100_DBG(IPW2100_DBG_BRUSSELS, (sc->sc_dip, CE_CONT,
2485                     "ipw2100_m_getprop(): Not Support DESIRED_RATES\n"));
2486                 break;
2487         case MAC_PROP_WL_RADIO:
2488                 *(wl_linkstatus_t *)wldp_buf = ipw2100_get_radio(sc);
2489                 break;
2490         default:
2491                 /* go through net80211 */
2492                 err = ieee80211_getprop(ic, pr_name, wldp_pr_num,
2493                     wldp_length, wldp_buf);
2494                 break;
2495         }
2496 
2497         return (err);
2498 }
2499 
2500 static void
2501 ipw2100_m_propinfo(void *arg, const char *pr_name, mac_prop_id_t wldp_pr_num,
2502     mac_prop_info_handle_t prh)
2503 {
2504         struct ipw2100_softc    *sc = (struct ipw2100_softc *)arg;
2505         struct ieee80211com     *ic = &sc->sc_ic;
2506 
2507         ieee80211_propinfo(ic, pr_name, wldp_pr_num, prh);
2508 
2509 }
2510 
2511 static int
2512 ipw2100_m_setprop(void *arg, const char *pr_name, mac_prop_id_t wldp_pr_num,
2513     uint_t wldp_length, const void *wldp_buf)
2514 {
2515         struct ipw2100_softc    *sc = (struct ipw2100_softc *)arg;
2516         struct ieee80211com     *ic = &sc->sc_ic;
2517         int                     err;
2518 
2519         switch (wldp_pr_num) {
2520         /* mac_prop_id */
2521         case MAC_PROP_WL_DESIRED_RATES:
2522                 IPW2100_DBG(IPW2100_DBG_BRUSSELS, (sc->sc_dip, CE_CONT,
2523                     "ipw2100_m_setprop(): Not Support DESIRED_RATES\n"));
2524                 err = ENOTSUP;
2525                 break;
2526         case MAC_PROP_WL_RADIO:
2527                 IPW2100_DBG(IPW2100_DBG_BRUSSELS, (sc->sc_dip, CE_CONT,
2528                     "ipw2100_m_setprop(): Not Support RADIO\n"));
2529                 err = ENOTSUP;
2530                 break;
2531         default:
2532                 /* go through net80211 */
2533                 err = ieee80211_setprop(ic, pr_name, wldp_pr_num, wldp_length,
2534                     wldp_buf);
2535                 break;
2536         }
2537 
2538         if (err == ENETRESET) {
2539                 if (sc->sc_flags & IPW2100_FLAG_RUNNING) {
2540                         (void) ipw2100_m_start(sc);
2541                         (void) ieee80211_new_state(ic,
2542                             IEEE80211_S_SCAN, -1);
2543                 }
2544 
2545                 err = 0;
2546         }
2547 
2548         return (err);
2549 }
2550 
2551 static int
2552 ipw_wificfg_radio(struct ipw2100_softc *sc, uint32_t cmd, wldp_t *outfp)
2553 {
2554         uint32_t        ret = ENOTSUP;
2555 
2556         switch (cmd) {
2557         case WLAN_GET_PARAM:
2558                 *(wl_linkstatus_t *)(outfp->wldp_buf) = ipw2100_get_radio(sc);
2559                 outfp->wldp_length = WIFI_BUF_OFFSET + sizeof (wl_linkstatus_t);
2560                 outfp->wldp_result = WL_SUCCESS;
2561                 ret = 0; /* command sucess */
2562                 break;
2563         case WLAN_SET_PARAM:
2564         default:
2565                 break;
2566         }
2567         return (ret);
2568 }
2569 
2570 static int
2571 ipw_wificfg_desrates(wldp_t *outfp)
2572 {
2573         /*
2574          * return success, but with result NOTSUPPORTED
2575          */
2576         outfp->wldp_length = WIFI_BUF_OFFSET;
2577         outfp->wldp_result = WL_NOTSUPPORTED;
2578         return (0);
2579 }
2580 
2581 static int
2582 ipw_wificfg_disassoc(struct ipw2100_softc *sc, wldp_t *outfp)
2583 {
2584         struct ieee80211com     *ic = &sc->sc_ic;
2585 
2586         /*
2587          * init the state
2588          */
2589         if (ic->ic_state != IEEE80211_S_INIT) {
2590                 (void) ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
2591         }
2592 
2593         /*
2594          * return success always
2595          */
2596         outfp->wldp_length = WIFI_BUF_OFFSET;
2597         outfp->wldp_result = WL_SUCCESS;
2598         return (0);
2599 }
2600 /* End of IOCTL Handler */
2601 
2602 static void
2603 ipw2100_fix_channel(struct ieee80211com *ic, mblk_t *m)
2604 {
2605         struct ieee80211_frame  *wh;
2606         uint8_t                 subtype;
2607         uint8_t                 *frm, *efrm;
2608 
2609         wh = (struct ieee80211_frame *)m->b_rptr;
2610 
2611         if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_MGT)
2612                 return;
2613 
2614         subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
2615 
2616         if (subtype != IEEE80211_FC0_SUBTYPE_BEACON &&
2617             subtype != IEEE80211_FC0_SUBTYPE_PROBE_RESP)
2618                 return;
2619 
2620         /*
2621          * assume the message contains only 1 block
2622          */
2623         frm   = (uint8_t *)(wh + 1);
2624         efrm  = (uint8_t *)m->b_wptr;
2625         frm  += 12;  /* skip tstamp, bintval and capinfo fields */
2626         while (frm < efrm) {
2627                 if (*frm == IEEE80211_ELEMID_DSPARMS) {
2628 #if IEEE80211_CHAN_MAX < 255
2629                         if (frm[2] <= IEEE80211_CHAN_MAX)
2630 #endif
2631                         {
2632                                 ic->ic_curchan = &ic->ic_sup_channels[frm[2]];
2633                         }
2634                 }
2635                 frm += frm[1] + 2;
2636         }
2637 }
2638 
2639 static void
2640 ipw2100_rcvpkt(struct ipw2100_softc *sc, struct ipw2100_status *status,
2641     uint8_t *rxbuf)
2642 {
2643         struct ieee80211com     *ic = &sc->sc_ic;
2644         mblk_t                  *m;
2645         struct ieee80211_frame  *wh = (struct ieee80211_frame *)rxbuf;
2646         struct ieee80211_node   *in;
2647         uint32_t                rlen;
2648 
2649         in = ieee80211_find_rxnode(ic, wh);
2650         rlen = LE_32(status->len);
2651         m = allocb(rlen, BPRI_MED);
2652         if (m) {
2653                 (void) memcpy(m->b_wptr, rxbuf, rlen);
2654                 m->b_wptr += rlen;
2655                 if (ic->ic_state == IEEE80211_S_SCAN)
2656                         ipw2100_fix_channel(ic, m);
2657                 (void) ieee80211_input(ic, m, in, status->rssi, 0);
2658         } else
2659                 IPW2100_WARN((sc->sc_dip, CE_WARN,
2660                     "ipw2100_rcvpkg(): cannot allocate receive message(%u)\n",
2661                     LE_32(status->len)));
2662         ieee80211_free_node(in);
2663 }
2664 
2665 static uint_t
2666 ipw2100_intr(caddr_t arg)
2667 {
2668         struct ipw2100_softc    *sc = (struct ipw2100_softc *)(uintptr_t)arg;
2669         uint32_t                ireg, ridx, len, i;
2670         struct ieee80211com     *ic = &sc->sc_ic;
2671         struct ipw2100_status   *status;
2672         uint8_t                 *rxbuf;
2673         struct dma_region       *dr;
2674         uint32_t                state;
2675 #if DEBUG
2676         struct ipw2100_bd *rxbd;
2677 #endif
2678 
2679         if (sc->sc_suspended)
2680                 return (DDI_INTR_UNCLAIMED);
2681 
2682         ireg = ipw2100_csr_get32(sc, IPW2100_CSR_INTR);
2683 
2684         if (!(ireg & IPW2100_INTR_MASK_ALL))
2685                 return (DDI_INTR_UNCLAIMED);
2686 
2687         /*
2688          * mask all interrupts
2689          */
2690         ipw2100_csr_put32(sc, IPW2100_CSR_INTR_MASK, 0);
2691 
2692         /*
2693          * acknowledge all fired interrupts
2694          */
2695         ipw2100_csr_put32(sc, IPW2100_CSR_INTR, ireg);
2696 
2697         IPW2100_DBG(IPW2100_DBG_INT, (sc->sc_dip, CE_CONT,
2698             "ipw2100_intr(): interrupt is fired. int=0x%08x\n", ireg));
2699 
2700         if (ireg & IPW2100_INTR_MASK_ERR) {
2701 
2702                 IPW2100_DBG(IPW2100_DBG_FATAL, (sc->sc_dip, CE_CONT,
2703                     "ipw2100_intr(): interrupt is fired, MASK = 0x%08x\n",
2704                     ireg));
2705 
2706                 /*
2707                  * inform mfthread to recover hw error
2708                  */
2709                 mutex_enter(&sc->sc_mflock);
2710                 sc->sc_flags |= IPW2100_FLAG_HW_ERR_RECOVER;
2711                 mutex_exit(&sc->sc_mflock);
2712 
2713                 goto enable_interrupt;
2714         }
2715 
2716         /*
2717          * FW intr
2718          */
2719         if (ireg & IPW2100_INTR_FW_INIT_DONE) {
2720                 mutex_enter(&sc->sc_ilock);
2721                 sc->sc_flags |= IPW2100_FLAG_FW_INITED;
2722                 cv_signal(&sc->sc_fw_cond);
2723                 mutex_exit(&sc->sc_ilock);
2724         }
2725 
2726         /*
2727          * RX intr
2728          */
2729         if (ireg & IPW2100_INTR_RX_TRANSFER) {
2730                 ridx = ipw2100_csr_get32(sc,
2731                     IPW2100_CSR_RX_READ_INDEX);
2732 
2733                 for (; sc->sc_rx_cur != ridx;
2734                     sc->sc_rx_cur = RING_FORWARD(
2735                     sc->sc_rx_cur, 1, IPW2100_NUM_RXBD)) {
2736 
2737                         i       = sc->sc_rx_cur;
2738                         status  = &sc->sc_status[i];
2739                         rxbuf   = &sc->sc_rxbufs[i]->rxb_dat[0];
2740                         dr      = &sc->sc_dma_rxbufs[i];
2741 
2742                         /*
2743                          * sync
2744                          */
2745                         (void) ddi_dma_sync(sc->sc_dma_status.dr_hnd,
2746                             i * sizeof (struct ipw2100_status),
2747                             sizeof (struct ipw2100_status),
2748                             DDI_DMA_SYNC_FORKERNEL);
2749                         (void) ddi_dma_sync(sc->sc_dma_rxbd.dr_hnd,
2750                             i * sizeof (struct ipw2100_bd),
2751                             sizeof (struct ipw2100_bd),
2752                             DDI_DMA_SYNC_FORKERNEL);
2753                         (void) ddi_dma_sync(dr->dr_hnd, 0,
2754                             sizeof (struct ipw2100_rxb),
2755                             DDI_DMA_SYNC_FORKERNEL);
2756                         IPW2100_DBG(IPW2100_DBG_INT, (sc->sc_dip, CE_CONT,
2757                             "ipw2100_intr(): status code=0x%04x, len=0x%08x, "
2758                             "flags=0x%02x, rssi=%02x\n",
2759                             LE_16(status->code), LE_32(status->len),
2760                             status->flags, status->rssi));
2761 #if DEBUG
2762                         rxbd    = &sc->sc_rxbd[i];
2763                         IPW2100_DBG(IPW2100_DBG_INT, (sc->sc_dip, CE_CONT,
2764                             "ipw2100_intr(): rxbd,phyaddr=0x%08x, len=0x%08x, "
2765                             "flags=0x%02x,nfrag=%02x\n",
2766                             LE_32(rxbd->phyaddr), LE_32(rxbd->len),
2767                             rxbd->flags, rxbd->nfrag));
2768 #endif
2769                         switch (LE_16(status->code) & 0x0f) {
2770                         /*
2771                          * command complete response
2772                          */
2773                         case IPW2100_STATUS_CODE_COMMAND:
2774                                 mutex_enter(&sc->sc_ilock);
2775                                 sc->sc_done = 1;
2776                                 cv_signal(&sc->sc_cmd_cond);
2777                                 mutex_exit(&sc->sc_ilock);
2778                                 break;
2779                         /*
2780                          * change state
2781                          */
2782                         case IPW2100_STATUS_CODE_NEWSTATE:
2783                                 state = LE_32(* ((uint32_t *)(uintptr_t)rxbuf));
2784                                 IPW2100_DBG(IPW2100_DBG_INT,
2785                                     (sc->sc_dip, CE_CONT,
2786                                     "ipw2100_intr(): newstate,state=0x%x\n",
2787                                     state));
2788 
2789                                 switch (state) {
2790                                 case IPW2100_STATE_ASSOCIATED:
2791                                         ieee80211_new_state(ic,
2792                                             IEEE80211_S_RUN, -1);
2793                                         break;
2794                                 case IPW2100_STATE_ASSOCIATION_LOST:
2795                                         case IPW2100_STATE_DISABLED:
2796                                         ieee80211_new_state(ic,
2797                                             IEEE80211_S_INIT, -1);
2798                                         break;
2799                                 /*
2800                                  * When radio is OFF, need a better
2801                                  * scan approach to ensure scan
2802                                  * result correct.
2803                                  */
2804                                 case IPW2100_STATE_RADIO_DISABLED:
2805                                         IPW2100_REPORT((sc->sc_dip, CE_WARN,
2806                                             "ipw2100_intr(): RADIO is OFF\n"));
2807                                         ipw2100_stop(sc);
2808                                         break;
2809                                 case IPW2100_STATE_SCAN_COMPLETE:
2810                                         ieee80211_cancel_scan(ic);
2811                                         break;
2812                                 case IPW2100_STATE_SCANNING:
2813                                         if (ic->ic_state != IEEE80211_S_RUN)
2814                                                 ieee80211_new_state(ic,
2815                                                     IEEE80211_S_SCAN, -1);
2816                                         ic->ic_flags |= IEEE80211_F_SCAN;
2817 
2818                                         break;
2819                                 default:
2820                                         break;
2821                                 }
2822                                 break;
2823                         case IPW2100_STATUS_CODE_DATA_802_11:
2824                         case IPW2100_STATUS_CODE_DATA_802_3:
2825                                 ipw2100_rcvpkt(sc, status, rxbuf);
2826                                 break;
2827                         case IPW2100_STATUS_CODE_NOTIFICATION:
2828                                 break;
2829                         default:
2830                                 IPW2100_WARN((sc->sc_dip, CE_WARN,
2831                                     "ipw2100_intr(): "
2832                                     "unknown status code 0x%04x\n",
2833                                     LE_16(status->code)));
2834                                 break;
2835                         }
2836                 }
2837                 /*
2838                  * write sc_rx_cur backward 1 step to RX_WRITE_INDEX
2839                  */
2840                 ipw2100_csr_put32(sc, IPW2100_CSR_RX_WRITE_INDEX,
2841                     RING_BACKWARD(sc->sc_rx_cur, 1, IPW2100_NUM_RXBD));
2842         }
2843 
2844         /*
2845          * TX intr
2846          */
2847         if (ireg & IPW2100_INTR_TX_TRANSFER) {
2848                 mutex_enter(&sc->sc_tx_lock);
2849                 ridx = ipw2100_csr_get32(sc, IPW2100_CSR_TX_READ_INDEX);
2850                 len = RING_FLEN(RING_FORWARD(sc->sc_tx_cur,
2851                     sc->sc_tx_free, IPW2100_NUM_TXBD),
2852                     ridx, IPW2100_NUM_TXBD);
2853                 sc->sc_tx_free += len;
2854                 IPW2100_DBG(IPW2100_DBG_INT, (sc->sc_dip, CE_CONT,
2855                     "ipw2100_intr(): len=%d\n", len));
2856                 mutex_exit(&sc->sc_tx_lock);
2857 
2858                 mutex_enter(&sc->sc_resched_lock);
2859                 if (len > 1 && (sc->sc_flags & IPW2100_FLAG_TX_SCHED)) {
2860                         sc->sc_flags &= ~IPW2100_FLAG_TX_SCHED;
2861                         mac_tx_update(ic->ic_mach);
2862                 }
2863                 mutex_exit(&sc->sc_resched_lock);
2864         }
2865 
2866 enable_interrupt:
2867         /*
2868          * enable all interrupts
2869          */
2870         ipw2100_csr_put32(sc, IPW2100_CSR_INTR_MASK, IPW2100_INTR_MASK_ALL);
2871 
2872         return (DDI_INTR_CLAIMED);
2873 }
2874 
2875 
2876 /*
2877  * Module Loading Data & Entry Points
2878  */
2879 DDI_DEFINE_STREAM_OPS(ipw2100_devops, nulldev, nulldev, ipw2100_attach,
2880     ipw2100_detach, nodev, NULL, D_MP, NULL, ipw2100_quiesce);
2881 
2882 static struct modldrv ipw2100_modldrv = {
2883         &mod_driverops,
2884         ipw2100_ident,
2885         &ipw2100_devops
2886 };
2887 
2888 static struct modlinkage ipw2100_modlinkage = {
2889         MODREV_1,
2890         &ipw2100_modldrv,
2891         NULL
2892 };
2893 
2894 int
2895 _init(void)
2896 {
2897         int     status;
2898 
2899         status = ddi_soft_state_init(&ipw2100_ssp,
2900             sizeof (struct ipw2100_softc), 1);
2901         if (status != DDI_SUCCESS)
2902                 return (status);
2903 
2904         mac_init_ops(&ipw2100_devops, IPW2100_DRV_NAME);
2905         status = mod_install(&ipw2100_modlinkage);
2906         if (status != DDI_SUCCESS) {
2907                 mac_fini_ops(&ipw2100_devops);
2908                 ddi_soft_state_fini(&ipw2100_ssp);
2909         }
2910 
2911         return (status);
2912 }
2913 
2914 int
2915 _fini(void)
2916 {
2917         int status;
2918 
2919         status = mod_remove(&ipw2100_modlinkage);
2920         if (status == DDI_SUCCESS) {
2921                 mac_fini_ops(&ipw2100_devops);
2922                 ddi_soft_state_fini(&ipw2100_ssp);
2923         }
2924 
2925         return (status);
2926 }
2927 
2928 int
2929 _info(struct modinfo *mip)
2930 {
2931         return (mod_info(&ipw2100_modlinkage, mip));
2932 }