1 /* 2 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 3 * Use is subject to license terms. 4 */ 5 6 /* 7 * Copyright (c) 2004, 2005 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 <sys/mac_wifi.h> 53 #include <sys/varargs.h> 54 #include <sys/pci.h> 55 #include <sys/policy.h> 56 #include <sys/random.h> 57 #include <sys/crypto/common.h> 58 #include <sys/crypto/api.h> 59 60 #include "ipw2200.h" 61 #include "ipw2200_impl.h" 62 #include <inet/wifi_ioctl.h> 63 64 /* 65 * for net80211 kernel usage 66 */ 67 #include <sys/net80211.h> 68 #include <sys/net80211_proto.h> 69 70 /* 71 * minimal size reserved in tx-ring 72 */ 73 #define IPW2200_TX_RING_MIN (8) 74 #define IPW2200_TXBUF_SIZE (IEEE80211_MAX_LEN) 75 #define IPW2200_RXBUF_SIZE (4096) 76 77 static void *ipw2200_ssp = NULL; 78 static char ipw2200_ident[] = IPW2200_DRV_DESC; 79 80 /* 81 * PIO access attributor for registers 82 */ 83 static ddi_device_acc_attr_t ipw2200_csr_accattr = { 84 DDI_DEVICE_ATTR_V0, 85 DDI_STRUCTURE_LE_ACC, 86 DDI_STRICTORDER_ACC 87 }; 88 89 /* 90 * DMA access attributor for descriptors 91 */ 92 static ddi_device_acc_attr_t ipw2200_dma_accattr = { 93 DDI_DEVICE_ATTR_V0, 94 DDI_NEVERSWAP_ACC, 95 DDI_STRICTORDER_ACC 96 }; 97 98 /* 99 * Describes the chip's DMA engine 100 */ 101 static ddi_dma_attr_t ipw2200_dma_attr = { 102 DMA_ATTR_V0, /* version */ 103 0x0000000000000000ULL, /* addr_lo */ 104 0x00000000ffffffffULL, /* addr_hi */ 105 0x00000000ffffffffULL, /* counter */ 106 0x0000000000000004ULL, /* alignment */ 107 0xfff, /* burst */ 108 1, /* min xfer */ 109 0x00000000ffffffffULL, /* max xfer */ 110 0x00000000ffffffffULL, /* seg boud */ 111 1, /* s/g list */ 112 1, /* granularity */ 113 0 /* flags */ 114 }; 115 116 static uint8_t ipw2200_broadcast_addr[] = { 117 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 118 }; 119 static const struct ieee80211_rateset ipw2200_rateset_11a = { 8, 120 {12, 18, 24, 36, 48, 72, 96, 108} 121 }; 122 static const struct ieee80211_rateset ipw2200_rateset_11b = { 4, 123 {2, 4, 11, 22} 124 }; 125 static const struct ieee80211_rateset ipw2200_rateset_11g = { 12, 126 {2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108} 127 }; 128 129 /* 130 * Used by multi function thread 131 */ 132 extern pri_t minclsyspri; 133 134 /* 135 * ipw2200 specific hardware operations 136 */ 137 static void ipw2200_hwconf_get(struct ipw2200_softc *sc); 138 static int ipw2200_chip_reset(struct ipw2200_softc *sc); 139 static void ipw2200_master_stop(struct ipw2200_softc *sc); 140 static void ipw2200_stop(struct ipw2200_softc *sc); 141 static int ipw2200_config(struct ipw2200_softc *sc); 142 static int ipw2200_cmd(struct ipw2200_softc *sc, 143 uint32_t type, void *buf, size_t len, int async); 144 static void ipw2200_ring_hwsetup(struct ipw2200_softc *sc); 145 static int ipw2200_ring_alloc(struct ipw2200_softc *sc); 146 static void ipw2200_ring_free(struct ipw2200_softc *sc); 147 static void ipw2200_ring_reset(struct ipw2200_softc *sc); 148 static int ipw2200_ring_init(struct ipw2200_softc *sc); 149 150 /* 151 * GLD specific operations 152 */ 153 static int ipw2200_m_stat(void *arg, uint_t stat, uint64_t *val); 154 static int ipw2200_m_start(void *arg); 155 static void ipw2200_m_stop(void *arg); 156 static int ipw2200_m_unicst(void *arg, const uint8_t *macaddr); 157 static int ipw2200_m_multicst(void *arg, boolean_t add, const uint8_t *m); 158 static int ipw2200_m_promisc(void *arg, boolean_t on); 159 static void ipw2200_m_ioctl(void *arg, queue_t *wq, mblk_t *mp); 160 static mblk_t *ipw2200_m_tx(void *arg, mblk_t *mp); 161 static int ipw2200_m_setprop(void *arg, const char *pr_name, 162 mac_prop_id_t wldp_pr_num, uint_t wldp_length, const void *wldp_buf); 163 static int ipw2200_m_getprop(void *arg, const char *pr_name, 164 mac_prop_id_t wldp_pr_num, uint_t wldp_length, void *wldp_buf); 165 static void ipw2200_m_propinfo(void *arg, const char *pr_name, 166 mac_prop_id_t wldp_pr_num, mac_prop_info_handle_t mph); 167 168 /* 169 * Interrupt and Data transferring operations 170 */ 171 static uint_t ipw2200_intr(caddr_t arg); 172 static int ipw2200_send(struct ieee80211com *ic, mblk_t *mp, uint8_t type); 173 static void ipw2200_rcv_frame(struct ipw2200_softc *sc, 174 struct ipw2200_frame *frame); 175 static void ipw2200_rcv_notif(struct ipw2200_softc *sc, 176 struct ipw2200_notif *notif); 177 178 /* 179 * WiFi specific operations 180 */ 181 static int ipw2200_newstate(struct ieee80211com *ic, 182 enum ieee80211_state state, int arg); 183 static void ipw2200_thread(struct ipw2200_softc *sc); 184 185 /* 186 * IOCTL Handler 187 */ 188 static int ipw2200_ioctl(struct ipw2200_softc *sc, queue_t *q, mblk_t *m); 189 static int ipw2200_getset(struct ipw2200_softc *sc, 190 mblk_t *m, uint32_t cmd, boolean_t *need_net80211); 191 static int iwi_wificfg_radio(struct ipw2200_softc *sc, 192 uint32_t cmd, wldp_t *outfp); 193 static int iwi_wificfg_desrates(wldp_t *outfp); 194 195 /* 196 * net80211 functions 197 */ 198 extern uint8_t ieee80211_crypto_getciphertype(ieee80211com_t *ic); 199 extern void ieee80211_notify_node_join(ieee80211com_t *ic, 200 ieee80211_node_t *in); 201 extern void ieee80211_notify_node_leave(ieee80211com_t *ic, 202 ieee80211_node_t *in); 203 204 /* 205 * Mac Call Back entries 206 */ 207 mac_callbacks_t ipw2200_m_callbacks = { 208 MC_IOCTL | MC_SETPROP | MC_GETPROP | MC_PROPINFO, 209 ipw2200_m_stat, 210 ipw2200_m_start, 211 ipw2200_m_stop, 212 ipw2200_m_promisc, 213 ipw2200_m_multicst, 214 ipw2200_m_unicst, 215 ipw2200_m_tx, 216 NULL, 217 ipw2200_m_ioctl, 218 NULL, 219 NULL, 220 NULL, 221 ipw2200_m_setprop, 222 ipw2200_m_getprop, 223 ipw2200_m_propinfo 224 }; 225 226 /* 227 * DEBUG Facility 228 */ 229 #define MAX_MSG (128) 230 uint32_t ipw2200_debug = 0; 231 /* 232 * supported debug marks are: 233 * | IPW2200_DBG_CSR 234 * | IPW2200_DBG_TABLE 235 * | IPW2200_DBG_HWCAP 236 * | IPW2200_DBG_TX 237 * | IPW2200_DBG_INIT 238 * | IPW2200_DBG_FW 239 * | IPW2200_DBG_NOTIF 240 * | IPW2200_DBG_SCAN 241 * | IPW2200_DBG_IOCTL 242 * | IPW2200_DBG_RING 243 * | IPW2200_DBG_INT 244 * | IPW2200_DBG_RX 245 * | IPW2200_DBG_DMA 246 * | IPW2200_DBG_GLD 247 * | IPW2200_DBG_WIFI 248 * | IPW2200_DBG_SOFTINT 249 * | IPW2200_DBG_SUSPEND 250 * | IPW2200_DBG_BRUSSELS 251 */ 252 253 /* 254 * Global tunning parameter to work around unknown hardware issues 255 */ 256 static uint32_t delay_config_stable = 100000; /* 100ms */ 257 static uint32_t delay_fatal_recover = 100000 * 20; /* 2s */ 258 static uint32_t delay_aux_thread = 100000; /* 100ms */ 259 260 #define IEEE80211_IS_CHAN_2GHZ(_c) \ 261 (((_c)->ich_flags & IEEE80211_CHAN_2GHZ) != 0) 262 #define IEEE80211_IS_CHAN_5GHZ(_c) \ 263 (((_c)->ich_flags & IEEE80211_CHAN_5GHZ) != 0) 264 #define isset(a, i) ((a)[(i)/NBBY] & (1 << ((i)%NBBY))) 265 266 void 267 ipw2200_dbg(dev_info_t *dip, int level, const char *fmt, ...) 268 { 269 va_list ap; 270 char buf[MAX_MSG]; 271 int instance; 272 273 va_start(ap, fmt); 274 (void) vsnprintf(buf, sizeof (buf), fmt, ap); 275 va_end(ap); 276 277 if (dip) { 278 instance = ddi_get_instance(dip); 279 cmn_err(level, "%s%d: %s", IPW2200_DRV_NAME, instance, buf); 280 } else 281 cmn_err(level, "%s: %s", IPW2200_DRV_NAME, buf); 282 283 } 284 285 /* 286 * Set up pci 287 */ 288 int 289 ipw2200_setup_pci(dev_info_t *dip, struct ipw2200_softc *sc) 290 { 291 ddi_acc_handle_t cfgh; 292 caddr_t regs; 293 int err; 294 295 /* 296 * Map config spaces register to read the vendor id, device id, sub 297 * vendor id, and sub device id. 298 */ 299 err = ddi_regs_map_setup(dip, IPW2200_PCI_CFG_RNUM, ®s, 300 0, 0, &ipw2200_csr_accattr, &cfgh); 301 if (err != DDI_SUCCESS) { 302 IPW2200_WARN((dip, CE_WARN, 303 "ipw2200_attach(): unable to map spaces regs\n")); 304 return (DDI_FAILURE); 305 } 306 307 ddi_put8(cfgh, (uint8_t *)(regs + 0x41), 0); 308 sc->sc_vendor = ddi_get16(cfgh, 309 (uint16_t *)((uintptr_t)regs + PCI_CONF_VENID)); 310 sc->sc_device = ddi_get16(cfgh, 311 (uint16_t *)((uintptr_t)regs + PCI_CONF_DEVID)); 312 sc->sc_subven = ddi_get16(cfgh, 313 (uint16_t *)((uintptr_t)regs + PCI_CONF_SUBVENID)); 314 sc->sc_subdev = ddi_get16(cfgh, 315 (uint16_t *)((uintptr_t)regs + PCI_CONF_SUBSYSID)); 316 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 317 "ipw2200_setup_pci(): vendor = 0x%04x, devic = 0x%04x," 318 "subversion = 0x%04x, subdev = 0x%04x", 319 sc->sc_vendor, sc->sc_device, sc->sc_subven, sc->sc_subdev)); 320 321 ddi_regs_map_free(&cfgh); 322 323 return (DDI_SUCCESS); 324 325 } 326 327 /* 328 * Device operations 329 */ 330 int 331 ipw2200_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 332 { 333 struct ipw2200_softc *sc; 334 struct ieee80211com *ic; 335 int instance, err, i; 336 char strbuf[32]; 337 wifi_data_t wd = { 0 }; 338 mac_register_t *macp; 339 340 switch (cmd) { 341 case DDI_ATTACH: 342 break; 343 case DDI_RESUME: 344 sc = ddi_get_soft_state(ipw2200_ssp, ddi_get_instance(dip)); 345 ASSERT(sc != NULL); 346 347 /* 348 * set up pci 349 */ 350 err = ipw2200_setup_pci(dip, sc); 351 if (err != DDI_SUCCESS) { 352 IPW2200_DBG(IPW2200_DBG_SUSPEND, (sc->sc_dip, CE_CONT, 353 "ipw2200_attach(): resume failure\n")); 354 return (DDI_FAILURE); 355 } 356 357 /* 358 * resume hardware. 359 * If it was on runnning status, reset to INIT state 360 */ 361 sc->sc_flags &= ~IPW2200_FLAG_SUSPEND; 362 if (sc->sc_flags & IPW2200_FLAG_RUNNING) 363 (void) ipw2200_init(sc); 364 365 IPW2200_DBG(IPW2200_DBG_SUSPEND, (sc->sc_dip, CE_CONT, 366 "ipw2200_attach(): resume successful\n")); 367 return (DDI_SUCCESS); 368 default: 369 return (DDI_FAILURE); 370 } 371 372 instance = ddi_get_instance(dip); 373 err = ddi_soft_state_zalloc(ipw2200_ssp, instance); 374 if (err != DDI_SUCCESS) { 375 IPW2200_WARN((dip, CE_WARN, 376 "ipw2200_attach(): unable to allocate soft state\n")); 377 goto fail1; 378 } 379 sc = ddi_get_soft_state(ipw2200_ssp, instance); 380 sc->sc_dip = dip; 381 382 /* set up pci, put reg+0x41 0 */ 383 err = ipw2200_setup_pci(dip, sc); 384 if (err != DDI_SUCCESS) { 385 IPW2200_WARN((dip, CE_WARN, 386 "ipw2200_attach(): unable to setup pci\n")); 387 goto fail2; 388 } 389 390 /* 391 * Map operating registers 392 */ 393 err = ddi_regs_map_setup(dip, IPW2200_PCI_CSR_RNUM, &sc->sc_regs, 394 0, 0, &ipw2200_csr_accattr, &sc->sc_ioh); 395 if (err != DDI_SUCCESS) { 396 IPW2200_WARN((dip, CE_WARN, 397 "ipw2200_attach(): ddi_regs_map_setup() failed\n")); 398 goto fail2; 399 } 400 401 /* 402 * Reset the chip 403 */ 404 err = ipw2200_chip_reset(sc); 405 if (err != DDI_SUCCESS) { 406 IPW2200_WARN((dip, CE_WARN, 407 "ipw2200_attach(): ipw2200_chip_reset() failed\n")); 408 goto fail3; 409 } 410 411 /* 412 * Get the hardware configuration, including the MAC address 413 * Then, init all the rings needed. 414 */ 415 ipw2200_hwconf_get(sc); 416 err = ipw2200_ring_init(sc); 417 if (err != DDI_SUCCESS) { 418 IPW2200_WARN((dip, CE_WARN, 419 "ipw2200_attach(): ipw2200_ring_init() failed\n")); 420 goto fail3; 421 } 422 423 /* 424 * Initialize mutexs and condvars 425 */ 426 err = ddi_get_iblock_cookie(dip, 0, &sc->sc_iblk); 427 if (err != DDI_SUCCESS) { 428 IPW2200_WARN((dip, CE_WARN, 429 "ipw2200_attach(): ddi_get_iblock_cookie() failed\n")); 430 goto fail4; 431 } 432 433 /* 434 * interrupt lock 435 */ 436 mutex_init(&sc->sc_ilock, "intr-lock", MUTEX_DRIVER, 437 (void *) sc->sc_iblk); 438 cv_init(&sc->sc_fw_cond, "firmware-ok", CV_DRIVER, NULL); 439 cv_init(&sc->sc_cmd_status_cond, "cmd-status-ring", CV_DRIVER, NULL); 440 441 /* 442 * command ring lock 443 */ 444 mutex_init(&sc->sc_cmd_lock, "cmd-ring", MUTEX_DRIVER, 445 (void *) sc->sc_iblk); 446 cv_init(&sc->sc_cmd_cond, "cmd-ring", CV_DRIVER, NULL); 447 448 /* 449 * tx ring lock 450 */ 451 mutex_init(&sc->sc_tx_lock, "tx-ring", MUTEX_DRIVER, 452 (void *) sc->sc_iblk); 453 454 /* 455 * rescheduled lock 456 */ 457 mutex_init(&sc->sc_resched_lock, "reschedule-lock", MUTEX_DRIVER, 458 (void *) sc->sc_iblk); 459 460 /* 461 * multi-function lock, may acquire this during interrupt 462 */ 463 mutex_init(&sc->sc_mflock, "function-lock", MUTEX_DRIVER, 464 (void *) sc->sc_iblk); 465 cv_init(&sc->sc_mfthread_cv, NULL, CV_DRIVER, NULL); 466 sc->sc_mf_thread = NULL; 467 sc->sc_mfthread_switch = 0; 468 469 /* 470 * Initialize the WiFi part 471 */ 472 ic = &sc->sc_ic; 473 ic->ic_phytype = IEEE80211_T_OFDM; 474 ic->ic_opmode = IEEE80211_M_STA; 475 ic->ic_state = IEEE80211_S_INIT; 476 ic->ic_maxrssi = 100; /* experimental number */ 477 ic->ic_caps = 478 IEEE80211_C_SHPREAMBLE | 479 IEEE80211_C_TXPMGT | 480 IEEE80211_C_PMGT | 481 IEEE80211_C_WPA; 482 483 /* 484 * set mac addr 485 */ 486 IEEE80211_ADDR_COPY(ic->ic_macaddr, sc->sc_macaddr); 487 488 /* 489 * set supported .11a rates and channel - (2915ABG only) 490 */ 491 if (sc->sc_device >= 0x4223) { 492 /* .11a rates */ 493 ic->ic_sup_rates[IEEE80211_MODE_11A] = ipw2200_rateset_11a; 494 /* .11a channels */ 495 for (i = 36; i <= 64; i += 4) { 496 ic->ic_sup_channels[i].ich_freq = 497 ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ); 498 ic->ic_sup_channels[i].ich_flags = /* CHAN_A */ 499 IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_OFDM; 500 } 501 for (i = 149; i <= 165; i += 4) { 502 ic->ic_sup_channels[i].ich_freq = 503 ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ); 504 ic->ic_sup_channels[i].ich_flags = /* CHAN_A */ 505 IEEE80211_CHAN_5GHZ | IEEE80211_CHAN_OFDM; 506 } 507 } 508 509 /* 510 * set supported .11b and .11g rates 511 */ 512 ic->ic_sup_rates[IEEE80211_MODE_11B] = ipw2200_rateset_11b; 513 ic->ic_sup_rates[IEEE80211_MODE_11G] = ipw2200_rateset_11g; 514 515 /* 516 * set supported .11b and .11g channels(1 through 14) 517 */ 518 for (i = 1; i < 14; i++) { 519 ic->ic_sup_channels[i].ich_freq = 520 ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ); 521 ic->ic_sup_channels[i].ich_flags = 522 IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM | 523 IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ; 524 } 525 526 /* 527 * IBSS channal undefined for now 528 */ 529 ic->ic_ibss_chan = &ic->ic_sup_channels[0]; 530 ic->ic_xmit = ipw2200_send; 531 532 /* 533 * init generic layer, then override state transition machine 534 */ 535 ieee80211_attach(ic); 536 537 /* 538 * different instance has different WPA door 539 */ 540 ieee80211_register_door(ic, ddi_driver_name(dip), instance); 541 542 /* 543 * Override 80211 default routines 544 */ 545 ieee80211_media_init(ic); /* initial the node table and bss */ 546 sc->sc_newstate = ic->ic_newstate; 547 ic->ic_newstate = ipw2200_newstate; 548 ic->ic_def_txkey = 0; 549 sc->sc_authmode = IEEE80211_AUTH_OPEN; 550 551 /* 552 * Add the interrupt handler 553 */ 554 err = ddi_add_intr(dip, 0, &sc->sc_iblk, NULL, 555 ipw2200_intr, (caddr_t)sc); 556 if (err != DDI_SUCCESS) { 557 IPW2200_WARN((dip, CE_WARN, 558 "ipw2200_attach(): ddi_add_intr() failed\n")); 559 goto fail5; 560 } 561 562 /* 563 * Initialize pointer to device specific functions 564 */ 565 wd.wd_secalloc = WIFI_SEC_NONE; 566 wd.wd_opmode = ic->ic_opmode; 567 IEEE80211_ADDR_COPY(wd.wd_bssid, ic->ic_bss->in_bssid); 568 569 macp = mac_alloc(MAC_VERSION); 570 if (err != 0) { 571 IPW2200_WARN((dip, CE_WARN, 572 "ipw2200_attach(): mac_alloc() failed\n")); 573 goto fail6; 574 } 575 576 macp->m_type_ident = MAC_PLUGIN_IDENT_WIFI; 577 macp->m_driver = sc; 578 macp->m_dip = dip; 579 macp->m_src_addr = ic->ic_macaddr; 580 macp->m_callbacks = &ipw2200_m_callbacks; 581 macp->m_min_sdu = 0; 582 macp->m_max_sdu = IEEE80211_MTU; 583 macp->m_pdata = &wd; 584 macp->m_pdata_size = sizeof (wd); 585 586 /* 587 * Register the macp to mac 588 */ 589 err = mac_register(macp, &ic->ic_mach); 590 mac_free(macp); 591 if (err != DDI_SUCCESS) { 592 IPW2200_WARN((dip, CE_WARN, 593 "ipw2200_attach(): mac_register() failed\n")); 594 goto fail6; 595 } 596 597 /* 598 * Create minor node of type DDI_NT_NET_WIFI 599 */ 600 (void) snprintf(strbuf, sizeof (strbuf), "%s%d", 601 IPW2200_DRV_NAME, instance); 602 err = ddi_create_minor_node(dip, strbuf, S_IFCHR, 603 instance + 1, DDI_NT_NET_WIFI, 0); 604 if (err != DDI_SUCCESS) 605 IPW2200_WARN((dip, CE_WARN, 606 "ipw2200_attach(): ddi_create_minor_node() failed\n")); 607 608 /* 609 * Cache firmware will always be true 610 */ 611 (void) ipw2200_cache_firmware(sc); 612 613 /* 614 * Notify link is down now 615 */ 616 mac_link_update(ic->ic_mach, LINK_STATE_DOWN); 617 618 /* 619 * Create the mf thread to handle the link status, 620 * recovery fatal error, etc. 621 */ 622 sc->sc_mfthread_switch = 1; 623 if (sc->sc_mf_thread == NULL) 624 sc->sc_mf_thread = thread_create((caddr_t)NULL, 0, 625 ipw2200_thread, sc, 0, &p0, TS_RUN, minclsyspri); 626 627 return (DDI_SUCCESS); 628 629 fail6: 630 ddi_remove_intr(dip, 0, sc->sc_iblk); 631 fail5: 632 ieee80211_detach(ic); 633 634 mutex_destroy(&sc->sc_ilock); 635 mutex_destroy(&sc->sc_cmd_lock); 636 mutex_destroy(&sc->sc_tx_lock); 637 mutex_destroy(&sc->sc_mflock); 638 mutex_destroy(&sc->sc_resched_lock); 639 cv_destroy(&sc->sc_fw_cond); 640 cv_destroy(&sc->sc_cmd_status_cond); 641 cv_destroy(&sc->sc_cmd_cond); 642 cv_destroy(&sc->sc_mfthread_cv); 643 fail4: 644 ipw2200_ring_free(sc); 645 fail3: 646 ddi_regs_map_free(&sc->sc_ioh); 647 fail2: 648 ddi_soft_state_free(ipw2200_ssp, instance); 649 fail1: 650 return (err); 651 } 652 653 654 int 655 ipw2200_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 656 { 657 struct ipw2200_softc *sc; 658 int err; 659 660 sc = ddi_get_soft_state(ipw2200_ssp, ddi_get_instance(dip)); 661 ASSERT(sc != NULL); 662 663 switch (cmd) { 664 case DDI_DETACH: 665 break; 666 case DDI_SUSPEND: 667 if (sc->sc_flags & IPW2200_FLAG_RUNNING) { 668 ipw2200_stop(sc); 669 } 670 sc->sc_flags |= IPW2200_FLAG_SUSPEND; 671 672 IPW2200_DBG(IPW2200_DBG_SUSPEND, (sc->sc_dip, CE_CONT, 673 "ipw2200_detach(): suspend\n")); 674 return (DDI_SUCCESS); 675 default: 676 return (DDI_FAILURE); 677 } 678 679 err = mac_disable(sc->sc_ic.ic_mach); 680 if (err != DDI_SUCCESS) 681 return (err); 682 683 ipw2200_stop(sc); 684 685 /* 686 * Destroy the mf_thread 687 */ 688 mutex_enter(&sc->sc_mflock); 689 sc->sc_mfthread_switch = 0; 690 while (sc->sc_mf_thread != NULL) { 691 if (cv_wait_sig(&sc->sc_mfthread_cv, &sc->sc_mflock) == 0) 692 break; 693 } 694 mutex_exit(&sc->sc_mflock); 695 696 /* 697 * Unregister from the MAC layer subsystem 698 */ 699 (void) mac_unregister(sc->sc_ic.ic_mach); 700 701 ddi_remove_intr(dip, IPW2200_PCI_INTR_NUM, sc->sc_iblk); 702 703 mutex_destroy(&sc->sc_ilock); 704 mutex_destroy(&sc->sc_cmd_lock); 705 mutex_destroy(&sc->sc_tx_lock); 706 mutex_destroy(&sc->sc_mflock); 707 mutex_destroy(&sc->sc_resched_lock); 708 cv_destroy(&sc->sc_fw_cond); 709 cv_destroy(&sc->sc_cmd_status_cond); 710 cv_destroy(&sc->sc_cmd_cond); 711 cv_destroy(&sc->sc_mfthread_cv); 712 713 /* 714 * Detach ieee80211 715 */ 716 ieee80211_detach(&sc->sc_ic); 717 718 (void) ipw2200_free_firmware(sc); 719 ipw2200_ring_free(sc); 720 721 ddi_regs_map_free(&sc->sc_ioh); 722 ddi_remove_minor_node(dip, NULL); 723 ddi_soft_state_free(ipw2200_ssp, ddi_get_instance(dip)); 724 725 return (DDI_SUCCESS); 726 } 727 728 /* 729 * quiesce(9E) entry point. 730 * This function is called when the system is single-threaded at high 731 * PIL with preemption disabled. Therefore, this function must not be 732 * blocked. 733 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure. 734 * DDI_FAILURE indicates an error condition and should almost never happen. 735 */ 736 static int 737 ipw2200_quiesce(dev_info_t *dip) 738 { 739 struct ipw2200_softc *sc = 740 ddi_get_soft_state(ipw2200_ssp, ddi_get_instance(dip)); 741 if (sc == NULL) 742 return (DDI_FAILURE); 743 744 /* by pass any messages, if it's quiesce */ 745 ipw2200_debug = 0; 746 747 /* 748 * No more blocking is allowed while we are in the 749 * quiesce(9E) entry point. 750 */ 751 sc->sc_flags |= IPW2200_FLAG_QUIESCED; 752 753 /* 754 * Disable and mask all interrupts. 755 */ 756 ipw2200_master_stop(sc); 757 ipw2200_csr_put32(sc, IPW2200_CSR_RST, IPW2200_RST_SW_RESET); 758 return (DDI_SUCCESS); 759 } 760 761 static void 762 ipw2200_stop(struct ipw2200_softc *sc) 763 { 764 struct ieee80211com *ic = &sc->sc_ic; 765 766 IPW2200_DBG(IPW2200_DBG_HWCAP, (sc->sc_dip, CE_CONT, 767 "ipw2200_stop(): enter\n")); 768 769 ipw2200_master_stop(sc); 770 ipw2200_csr_put32(sc, IPW2200_CSR_RST, IPW2200_RST_SW_RESET); 771 772 /* 773 * Reset ring 774 */ 775 ipw2200_ring_reset(sc); 776 777 ieee80211_new_state(ic, IEEE80211_S_INIT, -1); 778 sc->sc_flags &= ~IPW2200_FLAG_SCANNING; 779 sc->sc_flags &= ~IPW2200_FLAG_ASSOCIATED; 780 781 IPW2200_DBG(IPW2200_DBG_HWCAP, (sc->sc_dip, CE_CONT, 782 "ipw2200_stop(): exit\n")); 783 } 784 785 static int 786 ipw2200_config(struct ipw2200_softc *sc) 787 { 788 struct ieee80211com *ic = &sc->sc_ic; 789 struct ipw2200_configuration cfg; 790 uint32_t data; 791 struct ipw2200_txpower pwr; 792 struct ipw2200_rateset rs; 793 struct ipw2200_wep_key wkey; 794 int err, i; 795 796 /* 797 * Set the IBSS mode channel: Tx power 798 */ 799 if (ic->ic_opmode == IEEE80211_M_IBSS) { 800 pwr.mode = IPW2200_MODE_11B; 801 pwr.nchan = 11; 802 for (i = 0; i < pwr.nchan; i++) { 803 pwr.chan[i].chan = i + 1; 804 pwr.chan[i].power = IPW2200_TXPOWER_MAX; 805 } 806 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 807 "ipw2200_config(): Setting .11b channels Tx power\n")); 808 err = ipw2200_cmd(sc, IPW2200_CMD_SET_TX_POWER, 809 &pwr, sizeof (pwr), 0); 810 if (err != DDI_SUCCESS) 811 return (err); 812 813 pwr.mode = IPW2200_MODE_11G; 814 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 815 "ipw2200_config(): Setting .11g channels Tx power\n")); 816 err = ipw2200_cmd(sc, IPW2200_CMD_SET_TX_POWER, 817 &pwr, sizeof (pwr), 0); 818 if (err != DDI_SUCCESS) 819 return (err); 820 } 821 822 /* 823 * Set MAC address 824 */ 825 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 826 "ipw2200_config(): Setting MAC address to " 827 "%02x:%02x:%02x:%02x:%02x:%02x\n", 828 ic->ic_macaddr[0], ic->ic_macaddr[1], ic->ic_macaddr[2], 829 ic->ic_macaddr[3], ic->ic_macaddr[4], ic->ic_macaddr[5])); 830 err = ipw2200_cmd(sc, IPW2200_CMD_SET_MAC_ADDRESS, ic->ic_macaddr, 831 IEEE80211_ADDR_LEN, 0); 832 if (err != DDI_SUCCESS) 833 return (err); 834 835 /* 836 * Set basic system config settings: configuration(capabilities) 837 */ 838 (void) memset(&cfg, 0, sizeof (cfg)); 839 cfg.bluetooth_coexistence = 1; 840 cfg.multicast_enabled = 1; 841 cfg.answer_pbreq = 1; 842 cfg.noise_reported = 1; 843 cfg.disable_multicast_decryption = 1; /* WPA */ 844 cfg.disable_unicast_decryption = 1; /* WPA */ 845 846 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 847 "ipw2200_config(): Configuring adapter\n")); 848 err = ipw2200_cmd(sc, IPW2200_CMD_SET_CONFIG, 849 &cfg, sizeof (cfg), 0); 850 if (err != DDI_SUCCESS) 851 return (err); 852 853 /* 854 * Set power mode 855 */ 856 data = LE_32(IPW2200_POWER_MODE_CAM); 857 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 858 "ipw2200_config(): Setting power mode to %u\n", LE_32(data))); 859 err = ipw2200_cmd(sc, IPW2200_CMD_SET_POWER_MODE, 860 &data, sizeof (data), 0); 861 if (err != DDI_SUCCESS) 862 return (err); 863 864 /* 865 * Set supported rates 866 */ 867 rs.mode = IPW2200_MODE_11G; 868 rs.type = IPW2200_RATESET_TYPE_SUPPORTED; 869 rs.nrates = ic->ic_sup_rates[IEEE80211_MODE_11G].ir_nrates; 870 (void) memcpy(rs.rates, ic->ic_sup_rates[IEEE80211_MODE_11G].ir_rates, 871 rs.nrates); 872 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 873 "ipw2200_config(): Setting .11g supported rates(%u)\n", rs.nrates)); 874 err = ipw2200_cmd(sc, IPW2200_CMD_SET_RATES, &rs, sizeof (rs), 0); 875 if (err != DDI_SUCCESS) 876 return (err); 877 878 rs.mode = IPW2200_MODE_11A; 879 rs.type = IPW2200_RATESET_TYPE_SUPPORTED; 880 rs.nrates = ic->ic_sup_rates[IEEE80211_MODE_11A].ir_nrates; 881 (void) memcpy(rs.rates, ic->ic_sup_rates[IEEE80211_MODE_11A].ir_rates, 882 rs.nrates); 883 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 884 "ipw2200_config(): Setting .11a supported rates(%u)\n", rs.nrates)); 885 err = ipw2200_cmd(sc, IPW2200_CMD_SET_RATES, &rs, sizeof (rs), 0); 886 if (err != DDI_SUCCESS) 887 return (err); 888 889 /* 890 * Set RTS(request-to-send) threshold 891 */ 892 data = LE_32(ic->ic_rtsthreshold); 893 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 894 "ipw2200_config(): Setting RTS threshold to %u\n", LE_32(data))); 895 err = ipw2200_cmd(sc, IPW2200_CMD_SET_RTS_THRESHOLD, &data, 896 sizeof (data), 0); 897 if (err != DDI_SUCCESS) 898 return (err); 899 900 /* 901 * Set fragmentation threshold 902 */ 903 data = LE_32(ic->ic_fragthreshold); 904 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 905 "ipw2200_config(): Setting fragmentation threshold to %u\n", 906 LE_32(data))); 907 err = ipw2200_cmd(sc, IPW2200_CMD_SET_FRAG_THRESHOLD, &data, 908 sizeof (data), 0); 909 if (err != DDI_SUCCESS) 910 return (err); 911 912 /* 913 * Set desired ESSID if we have 914 */ 915 if (ic->ic_des_esslen != 0) { 916 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 917 "ipw2200_config(): Setting desired ESSID to " 918 "(%u),%c%c%c%c%c%c%c%c\n", 919 ic->ic_des_esslen, 920 ic->ic_des_essid[0], ic->ic_des_essid[1], 921 ic->ic_des_essid[2], ic->ic_des_essid[3], 922 ic->ic_des_essid[4], ic->ic_des_essid[5], 923 ic->ic_des_essid[6], ic->ic_des_essid[7])); 924 err = ipw2200_cmd(sc, IPW2200_CMD_SET_ESSID, ic->ic_des_essid, 925 ic->ic_des_esslen, 0); 926 if (err != DDI_SUCCESS) 927 return (err); 928 } 929 930 /* 931 * Set WEP initial vector(random seed) 932 */ 933 (void) random_get_pseudo_bytes((uint8_t *)&data, sizeof (data)); 934 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 935 "ipw2200_config(): Setting initialization vector to %u\n", 936 LE_32(data))); 937 err = ipw2200_cmd(sc, IPW2200_CMD_SET_IV, &data, sizeof (data), 0); 938 if (err != DDI_SUCCESS) 939 return (err); 940 941 /* 942 * Set WEP if any 943 */ 944 if (ic->ic_flags & IEEE80211_F_PRIVACY) { 945 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 946 "ipw2200_config(): Setting Wep Key\n", LE_32(data))); 947 for (i = 0; i < IEEE80211_WEP_NKID; i++) { 948 wkey.cmd = IPW2200_WEP_KEY_CMD_SETKEY; 949 wkey.idx = (uint8_t)i; 950 wkey.len = ic->ic_nw_keys[i].wk_keylen; 951 (void) memset(wkey.key, 0, sizeof (wkey.key)); 952 if (ic->ic_nw_keys[i].wk_keylen) 953 (void) memcpy(wkey.key, 954 ic->ic_nw_keys[i].wk_key, 955 ic->ic_nw_keys[i].wk_keylen); 956 err = ipw2200_cmd(sc, IPW2200_CMD_SET_WEP_KEY, 957 &wkey, sizeof (wkey), 0); 958 if (err != DDI_SUCCESS) 959 return (err); 960 } 961 } 962 963 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 964 "ipw2200_config(): Enabling adapter\n")); 965 966 return (ipw2200_cmd(sc, IPW2200_CMD_ENABLE, NULL, 0, 0)); 967 } 968 969 static int 970 ipw2200_cmd(struct ipw2200_softc *sc, 971 uint32_t type, void *buf, size_t len, int async) 972 { 973 struct ipw2200_cmd_desc *cmd; 974 clock_t clk; 975 uint32_t idx; 976 977 mutex_enter(&sc->sc_cmd_lock); 978 while (sc->sc_cmd_free < 1) 979 cv_wait(&sc->sc_cmd_cond, &sc->sc_cmd_lock); 980 981 idx = sc->sc_cmd_cur; 982 cmd = &sc->sc_cmdsc[idx]; 983 (void) memset(cmd, 0, sizeof (*cmd)); 984 985 IPW2200_DBG(IPW2200_DBG_RING, (sc->sc_dip, CE_CONT, 986 "ipw2200_cmd(): cmd-cur=%d\n", idx)); 987 988 cmd->hdr.type = IPW2200_HDR_TYPE_COMMAND; 989 cmd->hdr.flags = IPW2200_HDR_FLAG_IRQ; 990 cmd->type = (uint8_t)type; 991 if (len == 0 || buf == NULL) 992 cmd->len = 0; 993 else { 994 cmd->len = (uint8_t)len; 995 (void) memcpy(cmd->data, buf, len); 996 } 997 sc->sc_done[idx] = 0; 998 999 /* 1000 * DMA sync 1001 */ 1002 (void) ddi_dma_sync(sc->sc_dma_cmdsc.dr_hnd, 1003 idx * sizeof (struct ipw2200_cmd_desc), 1004 sizeof (struct ipw2200_cmd_desc), DDI_DMA_SYNC_FORDEV); 1005 1006 sc->sc_cmd_cur = RING_FORWARD(sc->sc_cmd_cur, 1, IPW2200_CMD_RING_SIZE); 1007 sc->sc_cmd_free--; 1008 1009 ipw2200_csr_put32(sc, IPW2200_CSR_CMD_WRITE_INDEX, sc->sc_cmd_cur); 1010 1011 mutex_exit(&sc->sc_cmd_lock); 1012 1013 if (async) 1014 goto out; 1015 1016 /* 1017 * Wait for command done 1018 */ 1019 clk = drv_usectohz(5000000); 1020 mutex_enter(&sc->sc_ilock); 1021 while (sc->sc_done[idx] == 0) { 1022 /* pending */ 1023 if (cv_reltimedwait(&sc->sc_cmd_status_cond, &sc->sc_ilock, 1024 clk, TR_CLOCK_TICK) < 0) 1025 break; 1026 } 1027 mutex_exit(&sc->sc_ilock); 1028 1029 IPW2200_DBG(IPW2200_DBG_RING, (sc->sc_dip, CE_CONT, 1030 "ipw2200_cmd(): cmd-done=%s\n", sc->sc_done[idx] ? "yes" : "no")); 1031 1032 if (sc->sc_done[idx] == 0) 1033 return (DDI_FAILURE); 1034 1035 out: 1036 return (DDI_SUCCESS); 1037 } 1038 1039 /* 1040 * If init failed, it will call stop internally. Therefore, it's unnecessary 1041 * to call ipw2200_stop() when this subroutine is failed. Otherwise, it may 1042 * be called twice. 1043 */ 1044 int 1045 ipw2200_init(struct ipw2200_softc *sc) 1046 { 1047 int err; 1048 1049 /* 1050 * No firmware is available, failed 1051 */ 1052 if (!(sc->sc_flags & IPW2200_FLAG_FW_CACHED)) { 1053 IPW2200_WARN((sc->sc_dip, CE_WARN, 1054 "ipw2200_init(): no firmware is available\n")); 1055 return (DDI_FAILURE); /* return directly */ 1056 } 1057 1058 ipw2200_stop(sc); 1059 1060 err = ipw2200_chip_reset(sc); 1061 if (err != DDI_SUCCESS) { 1062 IPW2200_WARN((sc->sc_dip, CE_WARN, 1063 "ipw2200_init(): could not reset adapter\n")); 1064 goto fail; 1065 } 1066 1067 /* 1068 * Load boot code 1069 */ 1070 err = ipw2200_load_fw(sc, sc->sc_fw.boot_base, sc->sc_fw.boot_size); 1071 if (err != DDI_SUCCESS) { 1072 IPW2200_WARN((sc->sc_dip, CE_WARN, 1073 "ipw2200_init(): could not load boot code\n")); 1074 goto fail; 1075 } 1076 1077 /* 1078 * Load boot microcode 1079 */ 1080 err = ipw2200_load_uc(sc, sc->sc_fw.uc_base, sc->sc_fw.uc_size); 1081 if (err != DDI_SUCCESS) { 1082 IPW2200_WARN((sc->sc_dip, CE_WARN, 1083 "ipw2200_init(): could not load microcode\n")); 1084 goto fail; 1085 } 1086 1087 ipw2200_master_stop(sc); 1088 ipw2200_ring_hwsetup(sc); 1089 1090 /* 1091 * Load firmware 1092 */ 1093 err = ipw2200_load_fw(sc, sc->sc_fw.fw_base, sc->sc_fw.fw_size); 1094 if (err != DDI_SUCCESS) { 1095 IPW2200_WARN((sc->sc_dip, CE_WARN, 1096 "ipw2200_init(): could not load firmware\n")); 1097 goto fail; 1098 } 1099 1100 sc->sc_flags |= IPW2200_FLAG_FW_INITED; 1101 1102 /* 1103 * Hardware will be enabled after configuration 1104 */ 1105 err = ipw2200_config(sc); 1106 if (err != DDI_SUCCESS) { 1107 IPW2200_WARN((sc->sc_dip, CE_WARN, 1108 "ipw2200_init(): device configuration failed\n")); 1109 goto fail; 1110 } 1111 1112 /* 1113 * workround to prevent too many h/w error. 1114 * delay for a while till h/w is stable. 1115 */ 1116 delay(drv_usectohz(delay_config_stable)); 1117 1118 return (DDI_SUCCESS); /* return successfully */ 1119 fail: 1120 ipw2200_stop(sc); 1121 return (err); 1122 } 1123 1124 /* 1125 * get hardware configurations from EEPROM embedded within PRO/2200 1126 */ 1127 static void 1128 ipw2200_hwconf_get(struct ipw2200_softc *sc) 1129 { 1130 int i; 1131 uint16_t val; 1132 1133 /* 1134 * Get mac address 1135 */ 1136 i = 0; 1137 val = ipw2200_rom_get16(sc, IPW2200_EEPROM_MAC + 0); 1138 sc->sc_macaddr[i++] = val >> 8; 1139 sc->sc_macaddr[i++] = val & 0xff; 1140 val = ipw2200_rom_get16(sc, IPW2200_EEPROM_MAC + 1); 1141 sc->sc_macaddr[i++] = val >> 8; 1142 sc->sc_macaddr[i++] = val & 0xff; 1143 val = ipw2200_rom_get16(sc, IPW2200_EEPROM_MAC + 2); 1144 sc->sc_macaddr[i++] = val >> 8; 1145 sc->sc_macaddr[i++] = val & 0xff; 1146 1147 /* 1148 * formatted MAC address string 1149 */ 1150 (void) snprintf(sc->sc_macstr, sizeof (sc->sc_macstr), 1151 "%02x:%02x:%02x:%02x:%02x:%02x", 1152 sc->sc_macaddr[0], sc->sc_macaddr[1], 1153 sc->sc_macaddr[2], sc->sc_macaddr[3], 1154 sc->sc_macaddr[4], sc->sc_macaddr[5]); 1155 1156 } 1157 1158 /* 1159 * all ipw2200 interrupts will be masked by this routine 1160 */ 1161 static void 1162 ipw2200_master_stop(struct ipw2200_softc *sc) 1163 { 1164 int ntries; 1165 1166 /* 1167 * disable interrupts 1168 */ 1169 ipw2200_csr_put32(sc, IPW2200_CSR_INTR_MASK, 0); 1170 ipw2200_csr_put32(sc, IPW2200_CSR_RST, IPW2200_RST_STOP_MASTER); 1171 1172 /* 1173 * wait long enough to ensure hardware stop successfully. 1174 */ 1175 for (ntries = 0; ntries < 500; ntries++) { 1176 if (ipw2200_csr_get32(sc, IPW2200_CSR_RST) & 1177 IPW2200_RST_MASTER_DISABLED) 1178 break; 1179 /* wait for a while */ 1180 drv_usecwait(100); 1181 } 1182 if (ntries == 500) 1183 IPW2200_WARN((sc->sc_dip, CE_WARN, 1184 "ipw2200_master_stop(): timeout\n")); 1185 1186 ipw2200_csr_put32(sc, IPW2200_CSR_RST, 1187 IPW2200_RST_PRINCETON_RESET | 1188 ipw2200_csr_get32(sc, IPW2200_CSR_RST)); 1189 1190 sc->sc_flags &= ~IPW2200_FLAG_FW_INITED; 1191 } 1192 1193 /* 1194 * all ipw2200 interrupts will be masked by this routine 1195 */ 1196 static int 1197 ipw2200_chip_reset(struct ipw2200_softc *sc) 1198 { 1199 uint32_t tmp; 1200 int ntries, i; 1201 1202 ipw2200_master_stop(sc); 1203 1204 /* 1205 * Move adapter to DO state 1206 */ 1207 tmp = ipw2200_csr_get32(sc, IPW2200_CSR_CTL); 1208 ipw2200_csr_put32(sc, IPW2200_CSR_CTL, tmp | IPW2200_CTL_INIT); 1209 1210 /* 1211 * Initialize Phase-Locked Level (PLL) 1212 */ 1213 ipw2200_csr_put32(sc, IPW2200_CSR_READ_INT, IPW2200_READ_INT_INIT_HOST); 1214 1215 /* 1216 * Wait for clock stabilization 1217 */ 1218 for (ntries = 0; ntries < 1000; ntries++) { 1219 if (ipw2200_csr_get32(sc, IPW2200_CSR_CTL) & 1220 IPW2200_CTL_CLOCK_READY) 1221 break; 1222 drv_usecwait(200); 1223 } 1224 if (ntries == 1000) { 1225 IPW2200_WARN((sc->sc_dip, CE_WARN, 1226 "ipw2200_chip_reset(): timeout\n")); 1227 return (DDI_FAILURE); 1228 } 1229 1230 tmp = ipw2200_csr_get32(sc, IPW2200_CSR_RST); 1231 ipw2200_csr_put32(sc, IPW2200_CSR_RST, tmp | IPW2200_RST_SW_RESET); 1232 1233 drv_usecwait(10); 1234 1235 tmp = ipw2200_csr_get32(sc, IPW2200_CSR_CTL); 1236 ipw2200_csr_put32(sc, IPW2200_CSR_CTL, tmp | IPW2200_CTL_INIT); 1237 1238 /* 1239 * clear NIC memory 1240 */ 1241 ipw2200_csr_put32(sc, IPW2200_CSR_AUTOINC_ADDR, 0); 1242 for (i = 0; i < 0xc000; i++) 1243 ipw2200_csr_put32(sc, IPW2200_CSR_AUTOINC_DATA, 0); 1244 1245 return (DDI_SUCCESS); 1246 } 1247 1248 /* 1249 * This function is used by wificonfig/dladm to get the current 1250 * radio status, it is off/on 1251 */ 1252 int 1253 ipw2200_radio_status(struct ipw2200_softc *sc) 1254 { 1255 int val; 1256 1257 val = (ipw2200_csr_get32(sc, IPW2200_CSR_IO) & 1258 IPW2200_IO_RADIO_ENABLED) ? 1 : 0; 1259 1260 return (val); 1261 } 1262 /* 1263 * This function is used to get the statistic 1264 */ 1265 void 1266 ipw2200_get_statistics(struct ipw2200_softc *sc) 1267 { 1268 struct ieee80211com *ic = &sc->sc_ic; 1269 1270 uint32_t size, buf[128]; 1271 1272 if (!(sc->sc_flags & IPW2200_FLAG_FW_INITED)) { 1273 IPW2200_DBG(IPW2200_DBG_IOCTL, (sc->sc_dip, CE_CONT, 1274 "ipw2200_get_statistic(): fw doesn't download yet.")); 1275 return; 1276 } 1277 1278 size = min(ipw2200_csr_get32(sc, IPW2200_CSR_TABLE0_SIZE), 128 - 1); 1279 ipw2200_csr_getbuf32(sc, IPW2200_CSR_TABLE0_BASE, &buf[1], size); 1280 1281 /* 1282 * To retrieve the statistic information into proper places. There are 1283 * lot of information. These table will be read once a second. 1284 * Hopefully, it will not effect the performance. 1285 */ 1286 1287 /* 1288 * For the tx/crc information, we can get them from chip directly; 1289 * For the rx/wep error/(rts) related information, leave them net80211. 1290 */ 1291 /* WIFI_STAT_TX_FRAGS */ 1292 ic->ic_stats.is_tx_frags = (uint32_t)buf[5]; 1293 /* WIFI_STAT_MCAST_TX */ 1294 ic->ic_stats.is_tx_mcast = (uint32_t)buf[31]; 1295 /* WIFI_STAT_TX_RETRANS */ 1296 ic->ic_stats.is_tx_retries = (uint32_t)buf[56]; 1297 /* WIFI_STAT_TX_FAILED */ 1298 ic->ic_stats.is_tx_failed = (uint32_t)buf[57]; 1299 /* MAC_STAT_OBYTES */ 1300 ic->ic_stats.is_tx_bytes = (uint32_t)buf[64]; 1301 } 1302 1303 /* 1304 * DMA region alloc subroutine 1305 */ 1306 int 1307 ipw2200_dma_region_alloc(struct ipw2200_softc *sc, struct dma_region *dr, 1308 size_t size, uint_t dir, uint_t flags) 1309 { 1310 dev_info_t *dip = sc->sc_dip; 1311 int err; 1312 1313 IPW2200_DBG(IPW2200_DBG_DMA, (sc->sc_dip, CE_CONT, 1314 "ipw2200_dma_region_alloc(): size =%u\n", size)); 1315 1316 err = ddi_dma_alloc_handle(dip, &ipw2200_dma_attr, DDI_DMA_SLEEP, NULL, 1317 &dr->dr_hnd); 1318 if (err != DDI_SUCCESS) { 1319 IPW2200_DBG(IPW2200_DBG_DMA, (sc->sc_dip, CE_CONT, 1320 "ipw2200_dma_region_alloc(): " 1321 "ddi_dma_alloc_handle() failed\n")); 1322 goto fail0; 1323 } 1324 1325 err = ddi_dma_mem_alloc(dr->dr_hnd, size, &ipw2200_dma_accattr, 1326 flags, DDI_DMA_SLEEP, NULL, 1327 &dr->dr_base, &dr->dr_size, &dr->dr_acc); 1328 if (err != DDI_SUCCESS) { 1329 IPW2200_DBG(IPW2200_DBG_DMA, (sc->sc_dip, CE_CONT, 1330 "ipw2200_dma_region_alloc(): " 1331 "ddi_dma_mem_alloc() failed\n")); 1332 goto fail1; 1333 } 1334 1335 err = ddi_dma_addr_bind_handle(dr->dr_hnd, NULL, 1336 dr->dr_base, dr->dr_size, 1337 dir | flags, DDI_DMA_SLEEP, NULL, 1338 &dr->dr_cookie, &dr->dr_ccnt); 1339 if (err != DDI_DMA_MAPPED) { 1340 IPW2200_DBG(IPW2200_DBG_DMA, (sc->sc_dip, CE_CONT, 1341 "ipw2200_dma_region_alloc(): " 1342 "ddi_dma_addr_bind_handle() failed\n")); 1343 goto fail2; 1344 } 1345 1346 IPW2200_DBG(IPW2200_DBG_DMA, (sc->sc_dip, CE_CONT, 1347 "ipw2200_dma_region_alloc(): ccnt=%u\n", dr->dr_ccnt)); 1348 1349 if (dr->dr_ccnt != 1) { 1350 err = DDI_FAILURE; 1351 goto fail3; 1352 } 1353 1354 dr->dr_pbase = dr->dr_cookie.dmac_address; 1355 1356 IPW2200_DBG(IPW2200_DBG_DMA, (sc->sc_dip, CE_CONT, 1357 "ipw2200_dma_region_alloc(): get physical-base=0x%08x\n", 1358 dr->dr_pbase)); 1359 1360 return (DDI_SUCCESS); 1361 1362 fail3: 1363 (void) ddi_dma_unbind_handle(dr->dr_hnd); 1364 fail2: 1365 ddi_dma_mem_free(&dr->dr_acc); 1366 fail1: 1367 ddi_dma_free_handle(&dr->dr_hnd); 1368 fail0: 1369 return (err); 1370 } 1371 1372 void 1373 ipw2200_dma_region_free(struct dma_region *dr) 1374 { 1375 (void) ddi_dma_unbind_handle(dr->dr_hnd); 1376 ddi_dma_mem_free(&dr->dr_acc); 1377 ddi_dma_free_handle(&dr->dr_hnd); 1378 } 1379 1380 static int 1381 ipw2200_ring_alloc(struct ipw2200_softc *sc) 1382 { 1383 int err, i; 1384 1385 /* 1386 * tx desc ring 1387 */ 1388 sc->sc_dma_txdsc.dr_name = "ipw2200-tx-desc-ring"; 1389 err = ipw2200_dma_region_alloc(sc, &sc->sc_dma_txdsc, 1390 IPW2200_TX_RING_SIZE * sizeof (struct ipw2200_tx_desc), 1391 DDI_DMA_WRITE, DDI_DMA_CONSISTENT); 1392 if (err != DDI_SUCCESS) 1393 goto fail0; 1394 /* 1395 * tx buffer array 1396 */ 1397 for (i = 0; i < IPW2200_TX_RING_SIZE; i++) { 1398 sc->sc_dma_txbufs[i].dr_name = "ipw2200-tx-buf"; 1399 err = ipw2200_dma_region_alloc(sc, &sc->sc_dma_txbufs[i], 1400 IPW2200_TXBUF_SIZE, DDI_DMA_WRITE, DDI_DMA_STREAMING); 1401 if (err != DDI_SUCCESS) { 1402 while (i >= 0) { 1403 ipw2200_dma_region_free(&sc->sc_dma_txbufs[i]); 1404 i--; 1405 } 1406 goto fail1; 1407 } 1408 } 1409 /* 1410 * rx buffer array 1411 */ 1412 for (i = 0; i < IPW2200_RX_RING_SIZE; i++) { 1413 sc->sc_dma_rxbufs[i].dr_name = "ipw2200-rx-buf"; 1414 err = ipw2200_dma_region_alloc(sc, &sc->sc_dma_rxbufs[i], 1415 IPW2200_RXBUF_SIZE, DDI_DMA_READ, DDI_DMA_STREAMING); 1416 if (err != DDI_SUCCESS) { 1417 while (i >= 0) { 1418 ipw2200_dma_region_free(&sc->sc_dma_rxbufs[i]); 1419 i--; 1420 } 1421 goto fail2; 1422 } 1423 } 1424 /* 1425 * cmd desc ring 1426 */ 1427 sc->sc_dma_cmdsc.dr_name = "ipw2200-cmd-desc-ring"; 1428 err = ipw2200_dma_region_alloc(sc, &sc->sc_dma_cmdsc, 1429 IPW2200_CMD_RING_SIZE * sizeof (struct ipw2200_cmd_desc), 1430 DDI_DMA_WRITE, DDI_DMA_CONSISTENT); 1431 if (err != DDI_SUCCESS) 1432 goto fail3; 1433 1434 return (DDI_SUCCESS); 1435 1436 fail3: 1437 for (i = 0; i < IPW2200_RX_RING_SIZE; i++) 1438 ipw2200_dma_region_free(&sc->sc_dma_rxbufs[i]); 1439 fail2: 1440 for (i = 0; i < IPW2200_TX_RING_SIZE; i++) 1441 ipw2200_dma_region_free(&sc->sc_dma_txbufs[i]); 1442 fail1: 1443 ipw2200_dma_region_free(&sc->sc_dma_txdsc); 1444 fail0: 1445 return (err); 1446 } 1447 1448 static void 1449 ipw2200_ring_free(struct ipw2200_softc *sc) 1450 { 1451 int i; 1452 1453 /* 1454 * tx ring desc 1455 */ 1456 ipw2200_dma_region_free(&sc->sc_dma_txdsc); 1457 /* 1458 * tx buf 1459 */ 1460 for (i = 0; i < IPW2200_TX_RING_SIZE; i++) 1461 ipw2200_dma_region_free(&sc->sc_dma_txbufs[i]); 1462 /* 1463 * rx buf 1464 */ 1465 for (i = 0; i < IPW2200_RX_RING_SIZE; i++) 1466 ipw2200_dma_region_free(&sc->sc_dma_rxbufs[i]); 1467 /* 1468 * command ring desc 1469 */ 1470 ipw2200_dma_region_free(&sc->sc_dma_cmdsc); 1471 } 1472 1473 static void 1474 ipw2200_ring_reset(struct ipw2200_softc *sc) 1475 { 1476 int i; 1477 1478 /* 1479 * tx desc ring & buffer array 1480 */ 1481 sc->sc_tx_cur = 0; 1482 sc->sc_tx_free = IPW2200_TX_RING_SIZE; 1483 sc->sc_txdsc = (struct ipw2200_tx_desc *)sc->sc_dma_txdsc.dr_base; 1484 for (i = 0; i < IPW2200_TX_RING_SIZE; i++) 1485 sc->sc_txbufs[i] = (uint8_t *)sc->sc_dma_txbufs[i].dr_base; 1486 /* 1487 * rx buffer array 1488 */ 1489 sc->sc_rx_cur = 0; 1490 sc->sc_rx_free = IPW2200_RX_RING_SIZE; 1491 for (i = 0; i < IPW2200_RX_RING_SIZE; i++) 1492 sc->sc_rxbufs[i] = (uint8_t *)sc->sc_dma_rxbufs[i].dr_base; 1493 1494 /* 1495 * command desc ring 1496 */ 1497 sc->sc_cmd_cur = 0; 1498 sc->sc_cmd_free = IPW2200_CMD_RING_SIZE; 1499 sc->sc_cmdsc = (struct ipw2200_cmd_desc *)sc->sc_dma_cmdsc.dr_base; 1500 } 1501 1502 /* 1503 * tx, rx rings and command initialization 1504 */ 1505 static int 1506 ipw2200_ring_init(struct ipw2200_softc *sc) 1507 { 1508 int err; 1509 1510 err = ipw2200_ring_alloc(sc); 1511 if (err != DDI_SUCCESS) 1512 return (err); 1513 1514 ipw2200_ring_reset(sc); 1515 1516 return (DDI_SUCCESS); 1517 } 1518 1519 static void 1520 ipw2200_ring_hwsetup(struct ipw2200_softc *sc) 1521 { 1522 int i; 1523 1524 /* 1525 * command desc ring 1526 */ 1527 ipw2200_csr_put32(sc, IPW2200_CSR_CMD_BASE, sc->sc_dma_cmdsc.dr_pbase); 1528 ipw2200_csr_put32(sc, IPW2200_CSR_CMD_SIZE, IPW2200_CMD_RING_SIZE); 1529 ipw2200_csr_put32(sc, IPW2200_CSR_CMD_WRITE_INDEX, sc->sc_cmd_cur); 1530 1531 /* 1532 * tx desc ring. only tx1 is used, tx2, tx3, and tx4 are unused 1533 */ 1534 ipw2200_csr_put32(sc, IPW2200_CSR_TX1_BASE, sc->sc_dma_txdsc.dr_pbase); 1535 ipw2200_csr_put32(sc, IPW2200_CSR_TX1_SIZE, IPW2200_TX_RING_SIZE); 1536 ipw2200_csr_put32(sc, IPW2200_CSR_TX1_WRITE_INDEX, sc->sc_tx_cur); 1537 1538 /* 1539 * tx2, tx3, tx4 is not used 1540 */ 1541 ipw2200_csr_put32(sc, IPW2200_CSR_TX2_BASE, sc->sc_dma_txdsc.dr_pbase); 1542 ipw2200_csr_put32(sc, IPW2200_CSR_TX2_SIZE, IPW2200_TX_RING_SIZE); 1543 ipw2200_csr_put32(sc, IPW2200_CSR_TX2_READ_INDEX, 0); 1544 ipw2200_csr_put32(sc, IPW2200_CSR_TX2_WRITE_INDEX, 0); 1545 ipw2200_csr_put32(sc, IPW2200_CSR_TX3_BASE, sc->sc_dma_txdsc.dr_pbase); 1546 ipw2200_csr_put32(sc, IPW2200_CSR_TX3_SIZE, IPW2200_TX_RING_SIZE); 1547 ipw2200_csr_put32(sc, IPW2200_CSR_TX3_READ_INDEX, 0); 1548 ipw2200_csr_put32(sc, IPW2200_CSR_TX3_WRITE_INDEX, 0); 1549 ipw2200_csr_put32(sc, IPW2200_CSR_TX4_BASE, sc->sc_dma_txdsc.dr_pbase); 1550 ipw2200_csr_put32(sc, IPW2200_CSR_TX4_SIZE, IPW2200_TX_RING_SIZE); 1551 ipw2200_csr_put32(sc, IPW2200_CSR_TX4_READ_INDEX, 0); 1552 ipw2200_csr_put32(sc, IPW2200_CSR_TX4_WRITE_INDEX, 0); 1553 1554 /* 1555 * rx buffer ring 1556 */ 1557 for (i = 0; i < IPW2200_RX_RING_SIZE; i++) 1558 ipw2200_csr_put32(sc, IPW2200_CSR_RX_BASE + i * 4, 1559 sc->sc_dma_rxbufs[i].dr_pbase); 1560 /* 1561 * all rx buffer are empty, rx-rd-index == 0 && rx-wr-index == N-1 1562 */ 1563 ipw2200_csr_put32(sc, IPW2200_CSR_RX_WRITE_INDEX, 1564 RING_BACKWARD(sc->sc_rx_cur, 1, IPW2200_RX_RING_SIZE)); 1565 } 1566 1567 int 1568 ipw2200_start_scan(struct ipw2200_softc *sc) 1569 { 1570 struct ieee80211com *ic = &sc->sc_ic; 1571 struct ipw2200_scan scan; 1572 uint8_t *ch; 1573 int cnt, i; 1574 1575 IPW2200_DBG(IPW2200_DBG_SCAN, (sc->sc_dip, CE_CONT, 1576 "ipw2200_start_scan(): start scanning \n")); 1577 1578 /* 1579 * start scanning 1580 */ 1581 sc->sc_flags |= IPW2200_FLAG_SCANNING; 1582 1583 (void) memset(&scan, 0, sizeof (scan)); 1584 scan.type = (ic->ic_des_esslen != 0) ? IPW2200_SCAN_TYPE_BDIRECTED : 1585 IPW2200_SCAN_TYPE_BROADCAST; 1586 scan.dwelltime = LE_16(40); /* The interval is set up to 40 */ 1587 1588 /* 1589 * Compact supported channel number(5G) into a single buffer 1590 */ 1591 ch = scan.channels; 1592 cnt = 0; 1593 for (i = 0; i <= IEEE80211_CHAN_MAX; i++) { 1594 if (IEEE80211_IS_CHAN_5GHZ(&ic->ic_sup_channels[i]) && 1595 isset(ic->ic_chan_active, i)) { 1596 *++ch = (uint8_t)i; 1597 cnt++; 1598 } 1599 } 1600 *(ch - cnt) = IPW2200_CHAN_5GHZ | (uint8_t)cnt; 1601 ch = (cnt > 0) ? (ch + 1) : (scan.channels); 1602 1603 /* 1604 * Compact supported channel number(2G) into a single buffer 1605 */ 1606 cnt = 0; 1607 for (i = 0; i <= IEEE80211_CHAN_MAX; i++) { 1608 if (IEEE80211_IS_CHAN_2GHZ(&ic->ic_sup_channels[i]) && 1609 isset(ic->ic_chan_active, i)) { 1610 *++ch = (uint8_t)i; 1611 cnt++; 1612 } 1613 } 1614 *(ch - cnt) = IPW2200_CHAN_2GHZ | cnt; 1615 1616 return (ipw2200_cmd(sc, IPW2200_CMD_SCAN, &scan, sizeof (scan), 1)); 1617 } 1618 1619 int 1620 ipw2200_auth_and_assoc(struct ipw2200_softc *sc) 1621 { 1622 struct ieee80211com *ic = &sc->sc_ic; 1623 struct ieee80211_node *in = ic->ic_bss; 1624 struct ipw2200_configuration cfg; 1625 struct ipw2200_rateset rs; 1626 struct ipw2200_associate assoc; 1627 uint32_t data; 1628 int err; 1629 uint8_t *wpa_level; 1630 1631 if (sc->sc_flags & IPW2200_FLAG_ASSOCIATED) { 1632 /* already associated */ 1633 return (-1); 1634 } 1635 1636 /* 1637 * set the confiuration 1638 */ 1639 if (IEEE80211_IS_CHAN_2GHZ(in->in_chan)) { 1640 /* enable b/g auto-detection */ 1641 (void) memset(&cfg, 0, sizeof (cfg)); 1642 cfg.bluetooth_coexistence = 1; 1643 cfg.multicast_enabled = 1; 1644 cfg.use_protection = 1; 1645 cfg.answer_pbreq = 1; 1646 cfg.noise_reported = 1; 1647 cfg.disable_multicast_decryption = 1; /* WPA */ 1648 cfg.disable_unicast_decryption = 1; /* WPA */ 1649 err = ipw2200_cmd(sc, IPW2200_CMD_SET_CONFIG, 1650 &cfg, sizeof (cfg), 1); 1651 if (err != DDI_SUCCESS) 1652 return (err); 1653 } 1654 1655 /* 1656 * set the essid, may be null/hidden AP 1657 */ 1658 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 1659 "ipw2200_auth_and_assoc(): " 1660 "setting ESSID to(%u),%c%c%c%c%c%c%c%c\n", 1661 in->in_esslen, 1662 in->in_essid[0], in->in_essid[1], 1663 in->in_essid[2], in->in_essid[3], 1664 in->in_essid[4], in->in_essid[5], 1665 in->in_essid[6], in->in_essid[7])); 1666 err = ipw2200_cmd(sc, IPW2200_CMD_SET_ESSID, in->in_essid, 1667 in->in_esslen, 1); 1668 if (err != DDI_SUCCESS) 1669 return (err); 1670 1671 /* 1672 * set the rate: the rate set has already been ''negocitated'' 1673 */ 1674 rs.mode = IEEE80211_IS_CHAN_5GHZ(in->in_chan) ? 1675 IPW2200_MODE_11A : IPW2200_MODE_11G; 1676 rs.type = IPW2200_RATESET_TYPE_NEGOCIATED; 1677 rs.nrates = in->in_rates.ir_nrates; 1678 (void) memcpy(rs.rates, in->in_rates.ir_rates, in->in_rates.ir_nrates); 1679 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 1680 "ipw2200_auth_and_assoc(): " 1681 "setting negotiated rates to(nrates = %u)\n", rs.nrates)); 1682 err = ipw2200_cmd(sc, IPW2200_CMD_SET_RATES, &rs, sizeof (rs), 1); 1683 if (err != DDI_SUCCESS) 1684 return (err); 1685 1686 /* 1687 * invoke command associate 1688 */ 1689 (void) memset(&assoc, 0, sizeof (assoc)); 1690 1691 /* 1692 * set opt_ie to h/w if associated is WPA, opt_ie has been verified 1693 * by net80211 kernel module. 1694 */ 1695 if (ic->ic_opt_ie != NULL) { 1696 1697 wpa_level = (uint8_t *)ic->ic_opt_ie; 1698 1699 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 1700 "ipw2200_auth_and_assoc(): " 1701 "set wpa_ie and wpa_ie_len to h/w. " 1702 "length is %d\n" 1703 "opt_ie[0] = %02X - element vendor\n" 1704 "opt_ie[1] = %02X - length\n" 1705 "opt_ie[2,3,4] = %02X %02X %02X - oui\n" 1706 "opt_ie[5] = %02X - oui type\n" 1707 "opt_ie[6,7] = %02X %02X - spec version \n" 1708 "opt_ie[8,9,10,11] = %02X %02X %02X %02X - gk cipher\n" 1709 "opt_ie[12,13] = %02X %02X - pairwise key cipher(1)\n" 1710 "opt_ie[14,15,16,17] = %02X %02X %02X %02X - ciphers\n" 1711 "opt_ie[18,19] = %02X %02X - authselcont(1) \n" 1712 "opt_ie[20,21,22,23] = %02X %02X %02X %02X - authsels\n", 1713 wpa_level[1], wpa_level[0], wpa_level[1], 1714 wpa_level[2], wpa_level[3], wpa_level[4], 1715 wpa_level[5], wpa_level[6], wpa_level[7], 1716 wpa_level[8], wpa_level[9], wpa_level[10], 1717 wpa_level[11], wpa_level[12], wpa_level[13], 1718 wpa_level[14], wpa_level[15], wpa_level[16], 1719 wpa_level[17], wpa_level[18], wpa_level[19], 1720 wpa_level[20], wpa_level[21], wpa_level[22], 1721 wpa_level[23])); 1722 1723 err = ipw2200_cmd(sc, IPW2200_CMD_SET_OPTIE, 1724 ic->ic_opt_ie, ic->ic_opt_ie_len, 1); 1725 if (err != DDI_SUCCESS) 1726 return (err); 1727 } 1728 1729 /* 1730 * set the sensitive 1731 */ 1732 data = LE_32(in->in_rssi); 1733 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 1734 "ipw2200_auth_and_assoc(): " 1735 "setting sensitivity to rssi:(%u)\n", (uint8_t)in->in_rssi)); 1736 err = ipw2200_cmd(sc, IPW2200_CMD_SET_SENSITIVITY, 1737 &data, sizeof (data), 1); 1738 if (err != DDI_SUCCESS) 1739 return (err); 1740 1741 /* 1742 * set mode and channel for assocation command 1743 */ 1744 assoc.mode = IEEE80211_IS_CHAN_5GHZ(in->in_chan) ? 1745 IPW2200_MODE_11A : IPW2200_MODE_11G; 1746 assoc.chan = ieee80211_chan2ieee(ic, in->in_chan); 1747 1748 /* 1749 * use the value set to ic_bss to retraive current sharedmode 1750 */ 1751 if (ic->ic_bss->in_authmode == WL_SHAREDKEY) { 1752 assoc.auth = (ic->ic_def_txkey << 4) | IPW2200_AUTH_SHARED; 1753 IPW2200_DBG(IPW2200_DBG_IOCTL, (sc->sc_dip, CE_CONT, 1754 "ipw2200_auth_and_assoc(): " 1755 "associate to shared key mode, set thru. ioctl")); 1756 } 1757 1758 if (ic->ic_flags & IEEE80211_F_WPA) 1759 assoc.policy = LE_16(IPW2200_POLICY_WPA); /* RSN/WPA active */ 1760 (void) memcpy(assoc.tstamp, in->in_tstamp.data, 8); 1761 assoc.capinfo = LE_16(in->in_capinfo); 1762 assoc.lintval = LE_16(ic->ic_lintval); 1763 assoc.intval = LE_16(in->in_intval); 1764 IEEE80211_ADDR_COPY(assoc.bssid, in->in_bssid); 1765 if (ic->ic_opmode == IEEE80211_M_IBSS) 1766 IEEE80211_ADDR_COPY(assoc.dst, ipw2200_broadcast_addr); 1767 else 1768 IEEE80211_ADDR_COPY(assoc.dst, in->in_bssid); 1769 1770 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 1771 "ipw2200_auth_and_assoc(): " 1772 "associate to bssid(%2x:%2x:%2x:%2x:%2x:%2x:), " 1773 "chan(%u), auth(%u)\n", 1774 assoc.bssid[0], assoc.bssid[1], assoc.bssid[2], 1775 assoc.bssid[3], assoc.bssid[4], assoc.bssid[5], 1776 assoc.chan, assoc.auth)); 1777 return (ipw2200_cmd(sc, IPW2200_CMD_ASSOCIATE, 1778 &assoc, sizeof (assoc), 1)); 1779 } 1780 1781 /* 1782 * Send the dis-association command to h/w, will receive notification to claim 1783 * the connection is dis-associated. So, it's not marked as disassociated this 1784 * moment. 1785 */ 1786 static int 1787 ipw2200_disassoc(struct ipw2200_softc *sc) 1788 { 1789 struct ipw2200_associate assoc; 1790 assoc.type = 2; 1791 return (ipw2200_cmd(sc, IPW2200_CMD_ASSOCIATE, &assoc, 1792 sizeof (assoc), 1)); 1793 } 1794 1795 /* ARGSUSED */ 1796 static int 1797 ipw2200_newstate(struct ieee80211com *ic, enum ieee80211_state state, int arg) 1798 { 1799 struct ipw2200_softc *sc = (struct ipw2200_softc *)ic; 1800 wifi_data_t wd = { 0 }; 1801 1802 switch (state) { 1803 case IEEE80211_S_SCAN: 1804 if (!(sc->sc_flags & IPW2200_FLAG_SCANNING)) { 1805 ic->ic_flags |= IEEE80211_F_SCAN | IEEE80211_F_ASCAN; 1806 (void) ipw2200_start_scan(sc); 1807 } 1808 break; 1809 case IEEE80211_S_AUTH: 1810 /* 1811 * The firmware will fail if we are already associated 1812 */ 1813 if (sc->sc_flags & IPW2200_FLAG_ASSOCIATED) 1814 (void) ipw2200_disassoc(sc); 1815 (void) ipw2200_auth_and_assoc(sc); 1816 break; 1817 case IEEE80211_S_RUN: 1818 /* 1819 * We can send data now; update the fastpath with our 1820 * current associated BSSID and other relevant settings. 1821 */ 1822 wd.wd_secalloc = ieee80211_crypto_getciphertype(ic); 1823 wd.wd_opmode = ic->ic_opmode; 1824 IEEE80211_ADDR_COPY(wd.wd_bssid, ic->ic_bss->in_bssid); 1825 (void) mac_pdata_update(ic->ic_mach, &wd, sizeof (wd)); 1826 break; 1827 case IEEE80211_S_ASSOC: 1828 case IEEE80211_S_INIT: 1829 break; 1830 } 1831 1832 /* 1833 * notify to update the link, and WPA 1834 */ 1835 if ((ic->ic_state != IEEE80211_S_RUN) && (state == IEEE80211_S_RUN)) { 1836 ieee80211_notify_node_join(ic, ic->ic_bss); 1837 } else if ((ic->ic_state == IEEE80211_S_RUN) && 1838 (state != IEEE80211_S_RUN)) { 1839 ieee80211_notify_node_leave(ic, ic->ic_bss); 1840 } 1841 1842 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 1843 "ipw2200_newstat(): %s -> %s\n", 1844 ieee80211_state_name[ic->ic_state], 1845 ieee80211_state_name[state])); 1846 1847 ic->ic_state = state; 1848 return (DDI_SUCCESS); 1849 } 1850 /* 1851 * GLD operations 1852 */ 1853 /* ARGSUSED */ 1854 static int 1855 ipw2200_m_stat(void *arg, uint_t stat, uint64_t *val) 1856 { 1857 ieee80211com_t *ic = (ieee80211com_t *)arg; 1858 struct ipw2200_softc *sc = (struct ipw2200_softc *)ic; 1859 1860 IPW2200_DBG(IPW2200_DBG_GLD, (((struct ipw2200_softc *)arg)->sc_dip, 1861 CE_CONT, 1862 "ipw2200_m_stat(): enter\n")); 1863 /* 1864 * Some of below statistic data are from hardware, some from net80211 1865 */ 1866 switch (stat) { 1867 case MAC_STAT_NOXMTBUF: 1868 *val = ic->ic_stats.is_tx_nobuf; 1869 break; 1870 case MAC_STAT_IERRORS: 1871 *val = sc->sc_stats.sc_rx_len_err; 1872 break; 1873 case MAC_STAT_OERRORS: 1874 *val = sc->sc_stats.sc_tx_discard + 1875 sc->sc_stats.sc_tx_alloc_fail + 1876 sc->sc_stats.sc_tx_encap_fail + 1877 sc->sc_stats.sc_tx_crypto_fail; 1878 break; 1879 case MAC_STAT_RBYTES: 1880 *val = ic->ic_stats.is_rx_bytes; 1881 break; 1882 case MAC_STAT_IPACKETS: 1883 *val = ic->ic_stats.is_rx_frags; 1884 break; 1885 case MAC_STAT_OBYTES: 1886 *val = ic->ic_stats.is_tx_bytes; 1887 break; 1888 case MAC_STAT_OPACKETS: 1889 *val = ic->ic_stats.is_tx_frags; 1890 break; 1891 /* 1892 * Get below from hardware statistic, retraive net80211 value once 1s 1893 */ 1894 case WIFI_STAT_TX_FRAGS: 1895 case WIFI_STAT_MCAST_TX: 1896 case WIFI_STAT_TX_FAILED: 1897 case WIFI_STAT_TX_RETRANS: 1898 /* 1899 * Get blow information from net80211 1900 */ 1901 case WIFI_STAT_RTS_SUCCESS: 1902 case WIFI_STAT_RTS_FAILURE: 1903 case WIFI_STAT_ACK_FAILURE: 1904 case WIFI_STAT_RX_FRAGS: 1905 case WIFI_STAT_MCAST_RX: 1906 case WIFI_STAT_RX_DUPS: 1907 case WIFI_STAT_FCS_ERRORS: 1908 case WIFI_STAT_WEP_ERRORS: 1909 return (ieee80211_stat(ic, stat, val)); 1910 /* 1911 * Need be supported later 1912 */ 1913 case MAC_STAT_IFSPEED: 1914 default: 1915 return (ENOTSUP); 1916 } 1917 return (0); 1918 } 1919 1920 /* ARGSUSED */ 1921 static int 1922 ipw2200_m_multicst(void *arg, boolean_t add, const uint8_t *mca) 1923 { 1924 /* not supported */ 1925 IPW2200_DBG(IPW2200_DBG_GLD, (((struct ipw2200_softc *)arg)->sc_dip, 1926 CE_CONT, 1927 "ipw2200_m_multicst(): enter\n")); 1928 1929 return (0); 1930 } 1931 1932 /* 1933 * Multithread handler for linkstatus, fatal error recovery, get statistic 1934 */ 1935 static void 1936 ipw2200_thread(struct ipw2200_softc *sc) 1937 { 1938 struct ieee80211com *ic = &sc->sc_ic; 1939 enum ieee80211_state ostate; 1940 int32_t nlstate; 1941 int stat_cnt = 0; 1942 1943 IPW2200_DBG(IPW2200_DBG_SOFTINT, (sc->sc_dip, CE_CONT, 1944 "ipw2200_thread(): enter, linkstate %d\n", sc->sc_linkstate)); 1945 1946 mutex_enter(&sc->sc_mflock); 1947 1948 while (sc->sc_mfthread_switch) { 1949 /* 1950 * when radio is off or SUSPEND status, nothing to do 1951 */ 1952 if ((ipw2200_radio_status(sc) == 0) || 1953 sc->sc_flags & IPW2200_FLAG_SUSPEND) { 1954 goto wait_loop; 1955 } 1956 1957 /* 1958 * notify the link state 1959 */ 1960 if (ic->ic_mach && (sc->sc_flags & IPW2200_FLAG_LINK_CHANGE)) { 1961 1962 IPW2200_DBG(IPW2200_DBG_SOFTINT, (sc->sc_dip, CE_CONT, 1963 "ipw2200_thread(): link status --> %d\n", 1964 sc->sc_linkstate)); 1965 1966 sc->sc_flags &= ~IPW2200_FLAG_LINK_CHANGE; 1967 nlstate = sc->sc_linkstate; 1968 1969 mutex_exit(&sc->sc_mflock); 1970 mac_link_update(ic->ic_mach, nlstate); 1971 mutex_enter(&sc->sc_mflock); 1972 } 1973 1974 /* 1975 * recovery fatal error 1976 */ 1977 if (ic->ic_mach && 1978 (sc->sc_flags & IPW2200_FLAG_HW_ERR_RECOVER)) { 1979 1980 IPW2200_DBG(IPW2200_DBG_FATAL, (sc->sc_dip, CE_CONT, 1981 "ipw2200_thread(): " 1982 "try to recover fatal hw error\n")); 1983 1984 sc->sc_flags &= ~IPW2200_FLAG_HW_ERR_RECOVER; 1985 mutex_exit(&sc->sc_mflock); 1986 1987 /* stop again */ 1988 ostate = ic->ic_state; 1989 (void) ipw2200_init(sc); /* Force state machine */ 1990 1991 /* 1992 * workround. Delay for a while after init especially 1993 * when something wrong happened already. 1994 */ 1995 delay(drv_usectohz(delay_fatal_recover)); 1996 1997 /* 1998 * Init scan will recovery the original connection if 1999 * the original state is run 2000 */ 2001 if (ostate != IEEE80211_S_INIT) 2002 ieee80211_begin_scan(ic, 0); 2003 2004 mutex_enter(&sc->sc_mflock); 2005 } 2006 2007 /* 2008 * get statistic, the value will be retrieved by m_stat 2009 */ 2010 if (stat_cnt == 10) { 2011 2012 stat_cnt = 0; /* re-start */ 2013 mutex_exit(&sc->sc_mflock); 2014 ipw2200_get_statistics(sc); 2015 mutex_enter(&sc->sc_mflock); 2016 2017 } else 2018 stat_cnt++; /* until 1s */ 2019 2020 wait_loop: 2021 mutex_exit(&sc->sc_mflock); 2022 delay(drv_usectohz(delay_aux_thread)); 2023 mutex_enter(&sc->sc_mflock); 2024 2025 } 2026 sc->sc_mf_thread = NULL; 2027 cv_signal(&sc->sc_mfthread_cv); 2028 mutex_exit(&sc->sc_mflock); 2029 } 2030 2031 static int 2032 ipw2200_m_start(void *arg) 2033 { 2034 struct ipw2200_softc *sc = (struct ipw2200_softc *)arg; 2035 struct ieee80211com *ic = &sc->sc_ic; 2036 2037 IPW2200_DBG(IPW2200_DBG_GLD, (sc->sc_dip, CE_CONT, 2038 "ipw2200_m_start(): enter\n")); 2039 /* 2040 * initialize ipw2200 hardware, everything ok will start scan 2041 */ 2042 (void) ipw2200_init(sc); 2043 2044 /* 2045 * set the state machine to INIT 2046 */ 2047 ieee80211_new_state(ic, IEEE80211_S_INIT, -1); 2048 2049 sc->sc_flags |= IPW2200_FLAG_RUNNING; 2050 2051 /* 2052 * fix KCF bug. - workaround, need to fix it in net80211 2053 */ 2054 (void) crypto_mech2id(SUN_CKM_RC4); 2055 2056 return (0); 2057 } 2058 2059 static void 2060 ipw2200_m_stop(void *arg) 2061 { 2062 struct ipw2200_softc *sc = (struct ipw2200_softc *)arg; 2063 struct ieee80211com *ic = &sc->sc_ic; 2064 2065 IPW2200_DBG(IPW2200_DBG_GLD, (sc->sc_dip, CE_CONT, 2066 "ipw2200_m_stop(): enter\n")); 2067 2068 ipw2200_stop(sc); 2069 /* 2070 * set the state machine to INIT 2071 */ 2072 ieee80211_new_state(ic, IEEE80211_S_INIT, -1); 2073 2074 sc->sc_flags &= ~IPW2200_FLAG_RUNNING; 2075 } 2076 2077 static int 2078 ipw2200_m_unicst(void *arg, const uint8_t *macaddr) 2079 { 2080 struct ipw2200_softc *sc = (struct ipw2200_softc *)arg; 2081 struct ieee80211com *ic = &sc->sc_ic; 2082 int err; 2083 2084 IPW2200_DBG(IPW2200_DBG_GLD, (sc->sc_dip, CE_CONT, 2085 "ipw2200_m_unicst(): enter\n")); 2086 2087 IPW2200_DBG(IPW2200_DBG_GLD, (sc->sc_dip, CE_CONT, 2088 "ipw2200_m_unicst(): GLD setting MAC address to " 2089 "%02x:%02x:%02x:%02x:%02x:%02x\n", 2090 macaddr[0], macaddr[1], macaddr[2], 2091 macaddr[3], macaddr[4], macaddr[5])); 2092 2093 if (!IEEE80211_ADDR_EQ(ic->ic_macaddr, macaddr)) { 2094 2095 IEEE80211_ADDR_COPY(ic->ic_macaddr, macaddr); 2096 2097 if (sc->sc_flags & IPW2200_FLAG_RUNNING) { 2098 err = ipw2200_config(sc); 2099 if (err != DDI_SUCCESS) { 2100 IPW2200_WARN((sc->sc_dip, CE_WARN, 2101 "ipw2200_m_unicst(): " 2102 "device configuration failed\n")); 2103 goto fail; 2104 } 2105 } 2106 } 2107 return (0); 2108 fail: 2109 return (EIO); 2110 } 2111 2112 static int 2113 ipw2200_m_promisc(void *arg, boolean_t on) 2114 { 2115 /* not supported */ 2116 struct ipw2200_softc *sc = (struct ipw2200_softc *)arg; 2117 2118 IPW2200_DBG(IPW2200_DBG_GLD, (sc->sc_dip, CE_CONT, 2119 "ipw2200_m_promisc(): enter. " 2120 "GLD setting promiscuous mode - %d\n", on)); 2121 2122 return (0); 2123 } 2124 2125 static mblk_t * 2126 ipw2200_m_tx(void *arg, mblk_t *mp) 2127 { 2128 struct ipw2200_softc *sc = (struct ipw2200_softc *)arg; 2129 struct ieee80211com *ic = &sc->sc_ic; 2130 mblk_t *next; 2131 2132 /* 2133 * when driver in on suspend state, freemsgchain directly 2134 */ 2135 if (sc->sc_flags & IPW2200_FLAG_SUSPEND) { 2136 IPW2200_DBG(IPW2200_DBG_SUSPEND, (sc->sc_dip, CE_CONT, 2137 "ipw2200_m_tx(): suspend status, discard msg\n")); 2138 sc->sc_stats.sc_tx_discard++; /* discard data */ 2139 freemsgchain(mp); 2140 return (NULL); 2141 } 2142 2143 /* 2144 * No data frames go out unless we're associated; this 2145 * should not happen as the 802.11 layer does not enable 2146 * the xmit queue until we enter the RUN state. 2147 */ 2148 if (ic->ic_state != IEEE80211_S_RUN) { 2149 IPW2200_DBG(IPW2200_DBG_GLD, (sc->sc_dip, CE_CONT, 2150 "ipw2200_m_tx(): discard msg, ic_state = %u\n", 2151 ic->ic_state)); 2152 sc->sc_stats.sc_tx_discard++; /* discard data */ 2153 freemsgchain(mp); 2154 return (NULL); 2155 } 2156 2157 while (mp != NULL) { 2158 next = mp->b_next; 2159 mp->b_next = NULL; 2160 if (ipw2200_send(ic, mp, IEEE80211_FC0_TYPE_DATA) == 2161 ENOMEM) { 2162 mp->b_next = next; 2163 break; 2164 } 2165 mp = next; 2166 } 2167 return (mp); 2168 } 2169 2170 /* 2171 * ipw2200_send(): send data. softway to handle crypto_encap. 2172 */ 2173 static int 2174 ipw2200_send(ieee80211com_t *ic, mblk_t *mp, uint8_t type) 2175 { 2176 struct ipw2200_softc *sc = (struct ipw2200_softc *)ic; 2177 struct ieee80211_node *in; 2178 struct ieee80211_frame *wh; 2179 struct ieee80211_key *k; 2180 mblk_t *m0, *m; 2181 size_t cnt, off; 2182 struct ipw2200_tx_desc *txdsc; 2183 struct dma_region *dr; 2184 uint32_t idx; 2185 int err = DDI_SUCCESS; 2186 /* tmp pointer, used to pack header and payload */ 2187 uint8_t *p; 2188 2189 ASSERT(mp->b_next == NULL); 2190 IPW2200_DBG(IPW2200_DBG_GLD, (sc->sc_dip, CE_CONT, 2191 "ipw2200_send(): enter\n")); 2192 2193 if ((type & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_DATA) { 2194 /* 2195 * skip all management frames since ipw2200 won't generate any 2196 * management frames. Therefore, drop this package. 2197 */ 2198 freemsg(mp); 2199 err = DDI_FAILURE; 2200 goto fail0; 2201 } 2202 2203 mutex_enter(&sc->sc_tx_lock); 2204 if (sc->sc_flags & IPW2200_FLAG_SUSPEND) { 2205 /* 2206 * when sending data, system runs into suspend status, 2207 * return fail directly 2208 */ 2209 err = ENXIO; 2210 goto fail0; 2211 } 2212 2213 /* 2214 * need 1 empty descriptor 2215 */ 2216 if (sc->sc_tx_free <= IPW2200_TX_RING_MIN) { 2217 mutex_enter(&sc->sc_resched_lock); 2218 IPW2200_DBG(IPW2200_DBG_RING, (sc->sc_dip, CE_WARN, 2219 "ipw2200_send(): no enough descriptors(%d)\n", 2220 sc->sc_tx_free)); 2221 ic->ic_stats.is_tx_nobuf++; /* no enough buffer */ 2222 sc->sc_flags |= IPW2200_FLAG_TX_SCHED; 2223 err = ENOMEM; 2224 mutex_exit(&sc->sc_resched_lock); 2225 goto fail1; 2226 } 2227 IPW2200_DBG(IPW2200_DBG_RING, (sc->sc_dip, CE_CONT, 2228 "ipw2200_send(): tx-free=%d,tx-curr=%d\n", 2229 sc->sc_tx_free, sc->sc_tx_cur)); 2230 2231 /* 2232 * put the mp into one blk, and use it to do the crypto_encap 2233 * if necessaary. 2234 */ 2235 m = allocb(msgdsize(mp) + 32, BPRI_MED); 2236 if (m == NULL) { /* can not alloc buf, drop this package */ 2237 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 2238 "ipw2200_send(): msg allocation failed\n")); 2239 freemsg(mp); 2240 sc->sc_stats.sc_tx_alloc_fail++; /* alloc fail */ 2241 ic->ic_stats.is_tx_failed++; /* trans failed */ 2242 err = DDI_FAILURE; 2243 goto fail1; 2244 } 2245 for (off = 0, m0 = mp; m0 != NULL; m0 = m0->b_cont) { 2246 cnt = MBLKL(m0); 2247 (void) memcpy(m->b_rptr + off, m0->b_rptr, cnt); 2248 off += cnt; 2249 } 2250 m->b_wptr += off; 2251 2252 /* 2253 * find tx_node, and encapsulate the data 2254 */ 2255 wh = (struct ieee80211_frame *)m->b_rptr; 2256 in = ieee80211_find_txnode(ic, wh->i_addr1); 2257 if (in == NULL) { /* can not find the tx node, drop the package */ 2258 sc->sc_stats.sc_tx_encap_fail++; /* tx encap fail */ 2259 ic->ic_stats.is_tx_failed++; /* trans failed */ 2260 freemsg(mp); 2261 err = DDI_FAILURE; 2262 goto fail2; 2263 } 2264 in->in_inact = 0; 2265 2266 (void) ieee80211_encap(ic, m, in); 2267 ieee80211_free_node(in); 2268 2269 if (wh->i_fc[1] & IEEE80211_FC1_WEP) { 2270 k = ieee80211_crypto_encap(ic, m); 2271 if (k == NULL) { /* can not get the key, drop packages */ 2272 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 2273 "ipw2200_send(): " 2274 "Encrypting 802.11 frame failed\n")); 2275 sc->sc_stats.sc_tx_crypto_fail++; /* tx encap fail */ 2276 ic->ic_stats.is_tx_failed++; /* trans failed */ 2277 freemsg(mp); 2278 err = DDI_FAILURE; 2279 goto fail2; 2280 } 2281 wh = (struct ieee80211_frame *)m->b_rptr; 2282 } 2283 2284 /* 2285 * get txdsc 2286 */ 2287 idx = sc->sc_tx_cur; 2288 txdsc = &sc->sc_txdsc[idx]; 2289 (void) memset(txdsc, 0, sizeof (*txdsc)); 2290 /* 2291 * extract header from message 2292 */ 2293 p = (uint8_t *)&txdsc->wh; 2294 off = sizeof (struct ieee80211_frame); 2295 (void) memcpy(p, m->b_rptr, off); 2296 /* 2297 * extract payload from message 2298 */ 2299 dr = &sc->sc_dma_txbufs[idx]; 2300 p = sc->sc_txbufs[idx]; 2301 cnt = MBLKL(m); 2302 (void) memcpy(p, m->b_rptr + off, cnt - off); 2303 cnt -= off; 2304 2305 txdsc->hdr.type = IPW2200_HDR_TYPE_DATA; 2306 txdsc->hdr.flags = IPW2200_HDR_FLAG_IRQ; 2307 txdsc->cmd = IPW2200_DATA_CMD_TX; 2308 txdsc->len = LE_16(cnt); 2309 txdsc->flags = 0; 2310 2311 if (ic->ic_opmode == IEEE80211_M_IBSS) { 2312 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) 2313 txdsc->flags |= IPW2200_DATA_FLAG_NEED_ACK; 2314 } else if (!IEEE80211_IS_MULTICAST(wh->i_addr3)) 2315 txdsc->flags |= IPW2200_DATA_FLAG_NEED_ACK; 2316 2317 /* always set it to none wep, because it's handled by software */ 2318 txdsc->flags |= IPW2200_DATA_FLAG_NO_WEP; 2319 2320 if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) 2321 txdsc->flags |= IPW2200_DATA_FLAG_SHPREAMBLE; 2322 2323 txdsc->nseg = LE_32(1); 2324 txdsc->seg_addr[0] = LE_32(dr->dr_pbase); 2325 txdsc->seg_len[0] = LE_32(cnt); 2326 2327 /* 2328 * DMA sync: buffer and desc 2329 */ 2330 (void) ddi_dma_sync(dr->dr_hnd, 0, 2331 IPW2200_TXBUF_SIZE, DDI_DMA_SYNC_FORDEV); 2332 (void) ddi_dma_sync(sc->sc_dma_txdsc.dr_hnd, 2333 idx * sizeof (struct ipw2200_tx_desc), 2334 sizeof (struct ipw2200_tx_desc), DDI_DMA_SYNC_FORDEV); 2335 2336 sc->sc_tx_cur = RING_FORWARD(sc->sc_tx_cur, 1, IPW2200_TX_RING_SIZE); 2337 sc->sc_tx_free--; 2338 2339 /* 2340 * update txcur 2341 */ 2342 ipw2200_csr_put32(sc, IPW2200_CSR_TX1_WRITE_INDEX, sc->sc_tx_cur); 2343 2344 /* 2345 * success, free the original message 2346 */ 2347 if (mp) 2348 freemsg(mp); 2349 fail2: 2350 if (m) 2351 freemsg(m); 2352 fail1: 2353 mutex_exit(&sc->sc_tx_lock); 2354 fail0: 2355 IPW2200_DBG(IPW2200_DBG_GLD, (sc->sc_dip, CE_CONT, 2356 "ipw2200_send(): exit - err=%d\n", err)); 2357 2358 return (err); 2359 } 2360 2361 /* 2362 * IOCTL handlers 2363 */ 2364 #define IEEE80211_IOCTL_REQUIRED (1) 2365 #define IEEE80211_IOCTL_NOT_REQUIRED (0) 2366 static void 2367 ipw2200_m_ioctl(void *arg, queue_t *q, mblk_t *m) 2368 { 2369 struct ipw2200_softc *sc = (struct ipw2200_softc *)arg; 2370 struct ieee80211com *ic = &sc->sc_ic; 2371 uint32_t err; 2372 2373 IPW2200_DBG(IPW2200_DBG_GLD, (sc->sc_dip, CE_CONT, 2374 "ipw2200_m_ioctl(): enter\n")); 2375 2376 /* 2377 * Check whether or not need to handle this in net80211 2378 * 2379 */ 2380 if (ipw2200_ioctl(sc, q, m) == IEEE80211_IOCTL_NOT_REQUIRED) 2381 return; 2382 2383 err = ieee80211_ioctl(ic, q, m); 2384 if (err == ENETRESET) { 2385 if (sc->sc_flags & IPW2200_FLAG_RUNNING) { 2386 (void) ipw2200_m_start(sc); 2387 (void) ieee80211_new_state(ic, 2388 IEEE80211_S_SCAN, -1); 2389 } 2390 } 2391 if (err == ERESTART) { 2392 if (sc->sc_flags & IPW2200_FLAG_RUNNING) 2393 (void) ipw2200_chip_reset(sc); 2394 } 2395 } 2396 static int 2397 ipw2200_ioctl(struct ipw2200_softc *sc, queue_t *q, mblk_t *m) 2398 { 2399 struct iocblk *iocp; 2400 uint32_t len, ret, cmd, mblen; 2401 mblk_t *m0; 2402 boolean_t need_privilege; 2403 boolean_t need_net80211; 2404 2405 mblen = MBLKL(m); 2406 if (mblen < sizeof (struct iocblk)) { 2407 IPW2200_DBG(IPW2200_DBG_IOCTL, (sc->sc_dip, CE_CONT, 2408 "ipw2200_ioctl(): ioctl buffer too short, %u\n", 2409 mblen)); 2410 miocnak(q, m, 0, EINVAL); 2411 /* 2412 * Buf not enough, do not need net80211 either 2413 */ 2414 return (IEEE80211_IOCTL_NOT_REQUIRED); 2415 } 2416 2417 /* 2418 * Validate the command 2419 */ 2420 iocp = (struct iocblk *)(uintptr_t)m->b_rptr; 2421 iocp->ioc_error = 0; 2422 cmd = iocp->ioc_cmd; 2423 need_privilege = B_TRUE; 2424 switch (cmd) { 2425 case WLAN_SET_PARAM: 2426 case WLAN_COMMAND: 2427 break; 2428 case WLAN_GET_PARAM: 2429 need_privilege = B_FALSE; 2430 break; 2431 default: 2432 IPW2200_DBG(IPW2200_DBG_IOCTL, (sc->sc_dip, CE_CONT, 2433 "ipw2200_ioctl(): unknown cmd 0x%x", cmd)); 2434 miocnak(q, m, 0, EINVAL); 2435 /* 2436 * Unknown cmd, do not need net80211 either 2437 */ 2438 return (IEEE80211_IOCTL_NOT_REQUIRED); 2439 } 2440 2441 if (need_privilege && (ret = secpolicy_dl_config(iocp->ioc_cr)) != 0) { 2442 miocnak(q, m, 0, ret); 2443 /* 2444 * privilege check fail, do not need net80211 either 2445 */ 2446 return (IEEE80211_IOCTL_NOT_REQUIRED); 2447 } 2448 2449 /* 2450 * sanity check 2451 */ 2452 m0 = m->b_cont; 2453 if (iocp->ioc_count == 0 || iocp->ioc_count < sizeof (wldp_t) || 2454 m0 == NULL) { 2455 miocnak(q, m, 0, EINVAL); 2456 /* 2457 * invalid format, do not need net80211 either 2458 */ 2459 return (IEEE80211_IOCTL_NOT_REQUIRED); 2460 } 2461 /* 2462 * assuming single data block 2463 */ 2464 if (m0->b_cont) { 2465 freemsg(m0->b_cont); 2466 m0->b_cont = NULL; 2467 } 2468 2469 need_net80211 = B_FALSE; 2470 ret = ipw2200_getset(sc, m0, cmd, &need_net80211); 2471 if (!need_net80211) { 2472 len = msgdsize(m0); 2473 2474 IPW2200_DBG(IPW2200_DBG_IOCTL, (sc->sc_dip, CE_CONT, 2475 "ipw2200_ioctl(): go to call miocack with " 2476 "ret = %d, len = %d\n", ret, len)); 2477 miocack(q, m, len, ret); 2478 return (IEEE80211_IOCTL_NOT_REQUIRED); 2479 } 2480 2481 /* 2482 * IEEE80211_IOCTL - need net80211 handle 2483 */ 2484 return (IEEE80211_IOCTL_REQUIRED); 2485 } 2486 2487 static int 2488 ipw2200_getset(struct ipw2200_softc *sc, mblk_t *m, uint32_t cmd, 2489 boolean_t *need_net80211) 2490 { 2491 wldp_t *infp, *outfp; 2492 uint32_t id; 2493 int ret; 2494 2495 infp = (wldp_t *)(uintptr_t)m->b_rptr; 2496 outfp = (wldp_t *)(uintptr_t)m->b_rptr; 2497 outfp->wldp_result = WL_NOTSUPPORTED; 2498 2499 id = infp->wldp_id; 2500 IPW2200_DBG(IPW2200_DBG_IOCTL, (sc->sc_dip, CE_CONT, 2501 "ipw2200_getset(): id = 0x%x\n", id)); 2502 switch (id) { 2503 case WL_RADIO: /* which is not supported by net80211 */ 2504 ret = iwi_wificfg_radio(sc, cmd, outfp); 2505 break; 2506 case WL_DESIRED_RATES: /* hardware doesn't support fix-rates */ 2507 ret = iwi_wificfg_desrates(outfp); 2508 break; 2509 default: 2510 /* 2511 * The wifi IOCTL net80211 supported: 2512 * case WL_ESSID: 2513 * case WL_BSSID: 2514 * case WL_WEP_KEY_TAB: 2515 * case WL_WEP_KEY_ID: 2516 * case WL_AUTH_MODE: 2517 * case WL_ENCRYPTION: 2518 * case WL_BSS_TYPE: 2519 * case WL_ESS_LIST: 2520 * case WL_LINKSTATUS: 2521 * case WL_RSSI: 2522 * case WL_SCAN: 2523 * case WL_LOAD_DEFAULTS: 2524 * case WL_DISASSOCIATE: 2525 */ 2526 2527 /* 2528 * When radio is off, need to ignore all ioctl. What need to 2529 * do is to check radio status firstly. If radio is ON, pass 2530 * it to net80211, otherwise, return to upper layer directly. 2531 * 2532 * Considering the WL_SUCCESS also means WL_CONNECTED for 2533 * checking linkstatus, one exception for WL_LINKSTATUS is to 2534 * let net80211 handle it. 2535 */ 2536 if ((ipw2200_radio_status(sc) == 0) && 2537 (id != WL_LINKSTATUS)) { 2538 2539 IPW2200_REPORT((sc->sc_dip, CE_CONT, 2540 "iwi: radio is OFF\n")); 2541 2542 outfp->wldp_length = WIFI_BUF_OFFSET; 2543 outfp->wldp_result = WL_SUCCESS; 2544 ret = 0; 2545 break; 2546 } 2547 2548 *need_net80211 = B_TRUE; /* let net80211 do the rest */ 2549 return (0); 2550 } 2551 /* 2552 * we will overwrite everything 2553 */ 2554 m->b_wptr = m->b_rptr + outfp->wldp_length; 2555 return (ret); 2556 } 2557 2558 /* 2559 * Call back functions for get/set proporty 2560 */ 2561 static int 2562 ipw2200_m_getprop(void *arg, const char *pr_name, mac_prop_id_t wldp_pr_num, 2563 uint_t wldp_length, void *wldp_buf) 2564 { 2565 struct ipw2200_softc *sc = (struct ipw2200_softc *)arg; 2566 struct ieee80211com *ic = &sc->sc_ic; 2567 int err = 0; 2568 2569 switch (wldp_pr_num) { 2570 /* mac_prop_id */ 2571 case MAC_PROP_WL_DESIRED_RATES: 2572 IPW2200_DBG(IPW2200_DBG_BRUSSELS, (sc->sc_dip, CE_CONT, 2573 "ipw2200_m_getprop(): Not Support DESIRED_RATES\n")); 2574 break; 2575 case MAC_PROP_WL_RADIO: 2576 *(wl_linkstatus_t *)wldp_buf = ipw2200_radio_status(sc); 2577 break; 2578 default: 2579 /* go through net80211 */ 2580 err = ieee80211_getprop(ic, pr_name, wldp_pr_num, 2581 wldp_length, wldp_buf); 2582 break; 2583 } 2584 2585 return (err); 2586 } 2587 2588 static void 2589 ipw2200_m_propinfo(void *arg, const char *pr_name, 2590 mac_prop_id_t wlpd_pr_num, mac_prop_info_handle_t mph) 2591 { 2592 struct ipw2200_softc *sc = (struct ipw2200_softc *)arg; 2593 struct ieee80211com *ic = &sc->sc_ic; 2594 2595 ieee80211_propinfo(ic, pr_name, wlpd_pr_num, mph); 2596 } 2597 2598 static int 2599 ipw2200_m_setprop(void *arg, const char *pr_name, mac_prop_id_t wldp_pr_num, 2600 uint_t wldp_length, const void *wldp_buf) 2601 { 2602 struct ipw2200_softc *sc = (struct ipw2200_softc *)arg; 2603 struct ieee80211com *ic = &sc->sc_ic; 2604 int err; 2605 2606 switch (wldp_pr_num) { 2607 /* mac_prop_id */ 2608 case MAC_PROP_WL_DESIRED_RATES: 2609 IPW2200_DBG(IPW2200_DBG_BRUSSELS, (sc->sc_dip, CE_CONT, 2610 "ipw2200_m_setprop(): Not Support DESIRED_RATES\n")); 2611 err = ENOTSUP; 2612 break; 2613 case MAC_PROP_WL_RADIO: 2614 IPW2200_DBG(IPW2200_DBG_BRUSSELS, (sc->sc_dip, CE_CONT, 2615 "ipw2200_m_setprop(): Not Support RADIO\n")); 2616 err = ENOTSUP; 2617 break; 2618 default: 2619 /* go through net80211 */ 2620 err = ieee80211_setprop(ic, pr_name, wldp_pr_num, wldp_length, 2621 wldp_buf); 2622 break; 2623 } 2624 2625 if (err == ENETRESET) { 2626 if (sc->sc_flags & IPW2200_FLAG_RUNNING) { 2627 (void) ipw2200_m_start(sc); 2628 (void) ieee80211_new_state(ic, 2629 IEEE80211_S_SCAN, -1); 2630 } 2631 err = 0; 2632 } 2633 2634 return (err); 2635 } 2636 2637 static int 2638 iwi_wificfg_radio(struct ipw2200_softc *sc, uint32_t cmd, wldp_t *outfp) 2639 { 2640 uint32_t ret = ENOTSUP; 2641 2642 switch (cmd) { 2643 case WLAN_GET_PARAM: 2644 *(wl_linkstatus_t *)(outfp->wldp_buf) = 2645 ipw2200_radio_status(sc); 2646 outfp->wldp_length = WIFI_BUF_OFFSET + sizeof (wl_linkstatus_t); 2647 outfp->wldp_result = WL_SUCCESS; 2648 ret = 0; /* command success */ 2649 break; 2650 case WLAN_SET_PARAM: 2651 default: 2652 break; 2653 } 2654 return (ret); 2655 } 2656 2657 static int 2658 iwi_wificfg_desrates(wldp_t *outfp) 2659 { 2660 /* return success, but with result NOTSUPPORTED */ 2661 outfp->wldp_length = WIFI_BUF_OFFSET; 2662 outfp->wldp_result = WL_NOTSUPPORTED; 2663 return (0); 2664 } 2665 /* End of IOCTL Handlers */ 2666 2667 void 2668 ipw2200_fix_channel(struct ieee80211com *ic, mblk_t *m) 2669 { 2670 struct ieee80211_frame *wh; 2671 uint8_t subtype; 2672 uint8_t *frm, *efrm; 2673 2674 wh = (struct ieee80211_frame *)m->b_rptr; 2675 2676 if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_MGT) 2677 return; 2678 2679 subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; 2680 2681 if (subtype != IEEE80211_FC0_SUBTYPE_BEACON && 2682 subtype != IEEE80211_FC0_SUBTYPE_PROBE_RESP) 2683 return; 2684 2685 /* 2686 * assume the message contains only 1 block 2687 */ 2688 frm = (uint8_t *)(wh + 1); 2689 efrm = (uint8_t *)m->b_wptr; 2690 frm += 12; /* skip tstamp, bintval and capinfo fields */ 2691 while (frm < efrm) { 2692 if (*frm == IEEE80211_ELEMID_DSPARMS) 2693 #if IEEE80211_CHAN_MAX < 255 2694 if (frm[2] <= IEEE80211_CHAN_MAX) 2695 #endif 2696 ic->ic_curchan = &ic->ic_sup_channels[frm[2]]; 2697 frm += frm[1] + 2; 2698 } 2699 } 2700 2701 static void 2702 ipw2200_rcv_frame(struct ipw2200_softc *sc, struct ipw2200_frame *frame) 2703 { 2704 struct ieee80211com *ic = &sc->sc_ic; 2705 uint8_t *data = (uint8_t *)frame; 2706 uint32_t len; 2707 struct ieee80211_frame *wh; 2708 struct ieee80211_node *in; 2709 mblk_t *m; 2710 2711 len = LE_16(frame->len); 2712 if ((len < sizeof (struct ieee80211_frame_min)) || 2713 (len > IPW2200_RXBUF_SIZE)) { 2714 IPW2200_DBG(IPW2200_DBG_RX, (sc->sc_dip, CE_CONT, 2715 "ipw2200_rcv_frame(): bad frame length=%u\n", 2716 LE_16(frame->len))); 2717 sc->sc_stats.sc_rx_len_err++; /* length doesn't work */ 2718 return; 2719 } 2720 IPW2200_DBG(IPW2200_DBG_RX, (sc->sc_dip, CE_CONT, 2721 "ipw2200_rcv_frame(): chan = %d, length = %d\n", frame->chan, len)); 2722 2723 /* 2724 * Skip the frame header, get the real data from the input 2725 */ 2726 data += sizeof (struct ipw2200_frame); 2727 2728 m = allocb(len, BPRI_MED); 2729 if (m) { 2730 (void) memcpy(m->b_wptr, data, len); 2731 m->b_wptr += len; 2732 2733 if (ic->ic_state == IEEE80211_S_SCAN) { 2734 ic->ic_ibss_chan = &ic->ic_sup_channels[frame->chan]; 2735 ipw2200_fix_channel(ic, m); 2736 } 2737 wh = (struct ieee80211_frame *)m->b_rptr; 2738 2739 in = ieee80211_find_rxnode(ic, wh); 2740 2741 IPW2200_DBG(IPW2200_DBG_RX, (sc->sc_dip, CE_CONT, 2742 "ipw2200_rcv_frame(): " 2743 "type = %x, subtype = %x, i_fc[1] = %x, " 2744 "ni_esslen:%d, ni_essid[0-5]:%c%c%c%c%c%c\n", 2745 wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK, 2746 wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK, 2747 wh->i_fc[1] & IEEE80211_FC1_WEP, 2748 in->in_esslen, 2749 in->in_essid[0], in->in_essid[1], in->in_essid[2], 2750 in->in_essid[3], in->in_essid[4], in->in_essid[5])); 2751 2752 (void) ieee80211_input(ic, m, in, frame->rssi_dbm, 0); 2753 2754 ieee80211_free_node(in); 2755 } 2756 else 2757 IPW2200_WARN((sc->sc_dip, CE_WARN, 2758 "ipw2200_rcv_frame(): " 2759 "cannot allocate receive message(%u)\n", 2760 LE_16(frame->len))); 2761 } 2762 2763 static void 2764 ipw2200_rcv_notif(struct ipw2200_softc *sc, struct ipw2200_notif *notif) 2765 { 2766 struct ieee80211com *ic = &sc->sc_ic; 2767 struct ipw2200_notif_association *assoc; 2768 struct ipw2200_notif_authentication *auth; 2769 uint8_t *ndata = (uint8_t *)notif; 2770 2771 IPW2200_DBG(IPW2200_DBG_NOTIF, (sc->sc_dip, CE_CONT, 2772 "ipw2200_rcv_notif(): type=%u\n", notif->type)); 2773 2774 ndata += sizeof (struct ipw2200_notif); 2775 switch (notif->type) { 2776 case IPW2200_NOTIF_TYPE_ASSOCIATION: 2777 assoc = (struct ipw2200_notif_association *)ndata; 2778 2779 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 2780 "ipw2200_rcv_notif(): association=%u,%u\n", 2781 assoc->state, assoc->status)); 2782 2783 switch (assoc->state) { 2784 case IPW2200_ASSOC_SUCCESS: 2785 sc->sc_flags |= IPW2200_FLAG_ASSOCIATED; 2786 ieee80211_new_state(ic, IEEE80211_S_RUN, -1); 2787 break; 2788 case IPW2200_ASSOC_FAIL: 2789 sc->sc_flags &= ~IPW2200_FLAG_ASSOCIATED; 2790 ieee80211_begin_scan(ic, 1); 2791 break; 2792 default: 2793 break; 2794 } 2795 break; 2796 2797 case IPW2200_NOTIF_TYPE_AUTHENTICATION: 2798 auth = (struct ipw2200_notif_authentication *)ndata; 2799 2800 IPW2200_DBG(IPW2200_DBG_WIFI, (sc->sc_dip, CE_CONT, 2801 "ipw2200_rcv_notif(): authentication=%u\n", auth->state)); 2802 2803 switch (auth->state) { 2804 case IPW2200_AUTH_SUCCESS: 2805 ieee80211_new_state(ic, IEEE80211_S_ASSOC, -1); 2806 break; 2807 case IPW2200_AUTH_FAIL: 2808 sc->sc_flags &= ~IPW2200_FLAG_ASSOCIATED; 2809 break; 2810 default: 2811 IPW2200_DBG(IPW2200_DBG_NOTIF, (sc->sc_dip, CE_CONT, 2812 "ipw2200_rcv_notif(): " 2813 "unknown authentication state(%u)\n", auth->state)); 2814 break; 2815 } 2816 break; 2817 2818 case IPW2200_NOTIF_TYPE_SCAN_CHANNEL: 2819 IPW2200_DBG(IPW2200_DBG_SCAN, (sc->sc_dip, CE_CONT, 2820 "ipw2200_rcv_notif(): scan-channel=%u\n", 2821 ((struct ipw2200_notif_scan_channel *)ndata)->nchan)); 2822 break; 2823 2824 case IPW2200_NOTIF_TYPE_SCAN_COMPLETE: 2825 IPW2200_DBG(IPW2200_DBG_SCAN, (sc->sc_dip, CE_CONT, 2826 "ipw2200_rcv_notif():scan-completed,(%u,%u)\n", 2827 ((struct ipw2200_notif_scan_complete *)ndata)->nchan, 2828 ((struct ipw2200_notif_scan_complete *)ndata)->status)); 2829 2830 /* 2831 * scan complete 2832 */ 2833 sc->sc_flags &= ~IPW2200_FLAG_SCANNING; 2834 ieee80211_end_scan(ic); 2835 break; 2836 2837 case IPW2200_NOTIF_TYPE_BEACON: 2838 case IPW2200_NOTIF_TYPE_CALIBRATION: 2839 case IPW2200_NOTIF_TYPE_NOISE: 2840 /* 2841 * just ignore 2842 */ 2843 break; 2844 default: 2845 IPW2200_DBG(IPW2200_DBG_NOTIF, (sc->sc_dip, CE_CONT, 2846 "ipw2200_rcv_notif(): unknown notification type(%u)\n", 2847 notif->type)); 2848 break; 2849 } 2850 } 2851 2852 static uint_t 2853 ipw2200_intr(caddr_t arg) 2854 { 2855 struct ipw2200_softc *sc = (struct ipw2200_softc *)(uintptr_t)arg; 2856 struct ieee80211com *ic = &sc->sc_ic; 2857 uint32_t ireg, ridx, len, i; 2858 uint8_t *p, *rxbuf; 2859 struct dma_region *dr; 2860 struct ipw2200_hdr *hdr; 2861 uint32_t widx; 2862 2863 /* when it is on suspend, unclaim all interrupt directly */ 2864 if (sc->sc_flags & IPW2200_FLAG_SUSPEND) 2865 return (DDI_INTR_UNCLAIMED); 2866 2867 /* unclaim interrupt when it is not for iwi */ 2868 ireg = ipw2200_csr_get32(sc, IPW2200_CSR_INTR); 2869 if (ireg == 0xffffffff || 2870 !(ireg & IPW2200_INTR_MASK_ALL)) 2871 return (DDI_INTR_UNCLAIMED); 2872 2873 /* 2874 * mask all interrupts 2875 */ 2876 ipw2200_csr_put32(sc, IPW2200_CSR_INTR_MASK, 0); 2877 2878 /* 2879 * acknowledge all fired interrupts 2880 */ 2881 ipw2200_csr_put32(sc, IPW2200_CSR_INTR, ireg); 2882 2883 IPW2200_DBG(IPW2200_DBG_INT, (sc->sc_dip, CE_CONT, 2884 "ipw2200_intr(): enter. interrupt fired, int=0x%08x\n", ireg)); 2885 2886 if (ireg & IPW2200_INTR_MASK_ERR) { 2887 2888 IPW2200_DBG(IPW2200_DBG_FATAL, (sc->sc_dip, CE_CONT, 2889 "ipw2200 interrupt(): int= 0x%08x\n", ireg)); 2890 2891 /* 2892 * inform mfthread to recover hw error by stopping it 2893 */ 2894 mutex_enter(&sc->sc_mflock); 2895 sc->sc_flags |= IPW2200_FLAG_HW_ERR_RECOVER; 2896 mutex_exit(&sc->sc_mflock); 2897 2898 goto enable_interrupt; 2899 } 2900 2901 /* 2902 * FW intr 2903 */ 2904 if (ireg & IPW2200_INTR_FW_INITED) { 2905 mutex_enter(&sc->sc_ilock); 2906 sc->sc_fw_ok = 1; 2907 cv_signal(&sc->sc_fw_cond); 2908 mutex_exit(&sc->sc_ilock); 2909 } 2910 2911 /* 2912 * Radio OFF 2913 */ 2914 if (ireg & IPW2200_INTR_RADIO_OFF) { 2915 IPW2200_REPORT((sc->sc_dip, CE_CONT, 2916 "ipw2200_intr(): radio is OFF\n")); 2917 2918 /* 2919 * Stop hardware, will notify LINK is down. 2920 * Need a better scan solution to ensure 2921 * table has right value. 2922 */ 2923 ipw2200_stop(sc); 2924 } 2925 2926 /* 2927 * CMD intr 2928 */ 2929 if (ireg & IPW2200_INTR_CMD_TRANSFER) { 2930 mutex_enter(&sc->sc_cmd_lock); 2931 ridx = ipw2200_csr_get32(sc, 2932 IPW2200_CSR_CMD_READ_INDEX); 2933 i = RING_FORWARD(sc->sc_cmd_cur, 2934 sc->sc_cmd_free, IPW2200_CMD_RING_SIZE); 2935 len = RING_FLEN(i, ridx, IPW2200_CMD_RING_SIZE); 2936 2937 IPW2200_DBG(IPW2200_DBG_INT, (sc->sc_dip, CE_CONT, 2938 "ipw2200_intr(): cmd-ring,i=%u,ridx=%u,len=%u\n", 2939 i, ridx, len)); 2940 2941 if (len > 0) { 2942 sc->sc_cmd_free += len; 2943 cv_signal(&sc->sc_cmd_cond); 2944 } 2945 for (; i != ridx; 2946 i = RING_FORWARD(i, 1, IPW2200_CMD_RING_SIZE)) 2947 sc->sc_done[i] = 1; 2948 mutex_exit(&sc->sc_cmd_lock); 2949 2950 mutex_enter(&sc->sc_ilock); 2951 cv_signal(&sc->sc_cmd_status_cond); 2952 mutex_exit(&sc->sc_ilock); 2953 } 2954 2955 /* 2956 * RX intr 2957 */ 2958 if (ireg & IPW2200_INTR_RX_TRANSFER) { 2959 ridx = ipw2200_csr_get32(sc, 2960 IPW2200_CSR_RX_READ_INDEX); 2961 widx = ipw2200_csr_get32(sc, 2962 IPW2200_CSR_RX_WRITE_INDEX); 2963 2964 IPW2200_DBG(IPW2200_DBG_INT, (sc->sc_dip, CE_CONT, 2965 "ipw2200_intr(): rx-ring,widx=%u,ridx=%u\n", 2966 ridx, widx)); 2967 2968 for (; sc->sc_rx_cur != ridx; 2969 sc->sc_rx_cur = RING_FORWARD(sc->sc_rx_cur, 1, 2970 IPW2200_RX_RING_SIZE)) { 2971 i = sc->sc_rx_cur; 2972 rxbuf = sc->sc_rxbufs[i]; 2973 dr = &sc->sc_dma_rxbufs[i]; 2974 2975 /* 2976 * DMA sync 2977 */ 2978 (void) ddi_dma_sync(dr->dr_hnd, 0, 2979 IPW2200_RXBUF_SIZE, DDI_DMA_SYNC_FORKERNEL); 2980 /* 2981 * Get rx header(hdr) and rx data(p) from rxbuf 2982 */ 2983 p = rxbuf; 2984 hdr = (struct ipw2200_hdr *)p; 2985 p += sizeof (struct ipw2200_hdr); 2986 2987 IPW2200_DBG(IPW2200_DBG_INT, (sc->sc_dip, CE_CONT, 2988 "ipw2200_intr(): Rx hdr type %u\n", 2989 hdr->type)); 2990 2991 switch (hdr->type) { 2992 case IPW2200_HDR_TYPE_FRAME: 2993 ipw2200_rcv_frame(sc, 2994 (struct ipw2200_frame *)p); 2995 break; 2996 2997 case IPW2200_HDR_TYPE_NOTIF: 2998 ipw2200_rcv_notif(sc, 2999 (struct ipw2200_notif *)p); 3000 break; 3001 3002 default: 3003 IPW2200_DBG(IPW2200_DBG_INT, (sc->sc_dip, 3004 CE_CONT, 3005 "ipw2200_intr(): unknown Rx hdr type %u\n", 3006 hdr->type)); 3007 break; 3008 } 3009 } 3010 /* 3011 * write sc_rx_cur backward 1 step into RX_WRITE_INDEX 3012 */ 3013 ipw2200_csr_put32(sc, IPW2200_CSR_RX_WRITE_INDEX, 3014 RING_BACKWARD(sc->sc_rx_cur, 1, 3015 IPW2200_RX_RING_SIZE)); 3016 } 3017 3018 /* 3019 * TX intr 3020 */ 3021 if (ireg & IPW2200_INTR_TX1_TRANSFER) { 3022 mutex_enter(&sc->sc_tx_lock); 3023 ridx = ipw2200_csr_get32(sc, 3024 IPW2200_CSR_TX1_READ_INDEX); 3025 len = RING_FLEN(RING_FORWARD(sc->sc_tx_cur, 3026 sc->sc_tx_free, IPW2200_TX_RING_SIZE), 3027 ridx, IPW2200_TX_RING_SIZE); 3028 sc->sc_tx_free += len; 3029 IPW2200_DBG(IPW2200_DBG_RING, (sc->sc_dip, CE_CONT, 3030 "ipw2200_intr(): tx-ring,ridx=%u,len=%u\n", 3031 ridx, len)); 3032 mutex_exit(&sc->sc_tx_lock); 3033 3034 mutex_enter(&sc->sc_resched_lock); 3035 if ((sc->sc_tx_free > IPW2200_TX_RING_MIN) && 3036 (sc->sc_flags & IPW2200_FLAG_TX_SCHED)) { 3037 IPW2200_DBG(IPW2200_DBG_RING, (sc->sc_dip, 3038 CE_CONT, 3039 "ipw2200_intr(): Need Reschedule!")); 3040 sc->sc_flags &= ~IPW2200_FLAG_TX_SCHED; 3041 mac_tx_update(ic->ic_mach); 3042 } 3043 mutex_exit(&sc->sc_resched_lock); 3044 } 3045 3046 enable_interrupt: 3047 /* 3048 * enable all interrupts 3049 */ 3050 ipw2200_csr_put32(sc, IPW2200_CSR_INTR_MASK, IPW2200_INTR_MASK_ALL); 3051 3052 return (DDI_INTR_CLAIMED); 3053 } 3054 3055 3056 /* 3057 * Module Loading Data & Entry Points 3058 */ 3059 DDI_DEFINE_STREAM_OPS(ipw2200_devops, nulldev, nulldev, ipw2200_attach, 3060 ipw2200_detach, nodev, NULL, D_MP, NULL, ipw2200_quiesce); 3061 3062 static struct modldrv ipw2200_modldrv = { 3063 &mod_driverops, 3064 ipw2200_ident, 3065 &ipw2200_devops 3066 }; 3067 3068 static struct modlinkage ipw2200_modlinkage = { 3069 MODREV_1, 3070 &ipw2200_modldrv, 3071 NULL 3072 }; 3073 3074 int 3075 _init(void) 3076 { 3077 int status; 3078 3079 status = ddi_soft_state_init(&ipw2200_ssp, 3080 sizeof (struct ipw2200_softc), 1); 3081 if (status != DDI_SUCCESS) 3082 return (status); 3083 3084 mac_init_ops(&ipw2200_devops, IPW2200_DRV_NAME); 3085 status = mod_install(&ipw2200_modlinkage); 3086 if (status != DDI_SUCCESS) { 3087 mac_fini_ops(&ipw2200_devops); 3088 ddi_soft_state_fini(&ipw2200_ssp); 3089 } 3090 3091 return (status); 3092 } 3093 3094 int 3095 _fini(void) 3096 { 3097 int status; 3098 3099 status = mod_remove(&ipw2200_modlinkage); 3100 if (status == DDI_SUCCESS) { 3101 mac_fini_ops(&ipw2200_devops); 3102 ddi_soft_state_fini(&ipw2200_ssp); 3103 } 3104 3105 return (status); 3106 } 3107 3108 int 3109 _info(struct modinfo *modinfop) 3110 { 3111 return (mod_info(&ipw2200_modlinkage, modinfop)); 3112 } 3113