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, ®s,
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_usectohz(1000000); /* 1 second */
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 adatper 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 }