1 /* $NetBSD: if_ray.c,v 1.84 2016/07/07 06:55:42 msaitoh Exp $ */ 2 3 /* 4 * Copyright (c) 2000 Christian E. Hopps 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the author nor the names of any co-contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 /* 33 * Driver for the Raylink (Raytheon) / WebGear IEEE 802.11 (FH) WLANs 34 * 35 * 2-way communication with the card is through command structures 36 * stored in shared ram. To communicate with the card a free 37 * command structure is filled in and then the card is interrupted. 38 * The card does the same with a different set of command structures. 39 * Only one command can be processed at a time. This is indicated 40 * by the interrupt having not been cleared since it was last set. 41 * The bit is cleared when the command has been processed (although 42 * it may not yet be complete). 43 * 44 * This driver was only tested with the Aviator 2.4 wireless 45 * The author didn't have the pro version or raylink to test 46 * with. 47 * 48 * N.B. Its unclear yet whether the Aviator 2.4 cards interoperate 49 * with other 802.11 FH 2Mbps cards, since this was also untested. 50 * Given the nature of the buggy build 4 firmware there may be problems. 51 * 52 * Authentication added by Steve Weiss <srw@alum.mit.edu> based on 53 * advice from Corey Thomas (author of the Linux RayLink driver). 54 * Authentication is currently limited to adhoc networks, and was 55 * added to support a requirement of the newest Windows drivers for 56 * the RayLink. Tested with Aviator Pro (firmware 5.63) on Win98. 57 */ 58 59 #include <sys/cdefs.h> 60 __KERNEL_RCSID(0, "$NetBSD: if_ray.c,v 1.84 2016/07/07 06:55:42 msaitoh Exp $"); 61 62 #include "opt_inet.h" 63 64 #include <sys/param.h> 65 #include <sys/systm.h> 66 #include <sys/callout.h> 67 #include <sys/mbuf.h> 68 #include <sys/socket.h> 69 #include <sys/ioctl.h> 70 #include <sys/errno.h> 71 #include <sys/device.h> 72 #include <sys/kernel.h> 73 #include <sys/proc.h> 74 75 #include <net/if.h> 76 #include <net/if_dl.h> 77 #include <net/if_ether.h> 78 #include <net/if_media.h> 79 #include <net/if_llc.h> 80 #include <net80211/ieee80211.h> 81 #include <net80211/ieee80211_ioctl.h> 82 #include <net/if_media.h> 83 84 #ifdef INET 85 #include <netinet/in.h> 86 #include <netinet/in_systm.h> 87 #include <netinet/in_var.h> 88 #include <netinet/ip.h> 89 #include <netinet/if_inarp.h> 90 #endif 91 92 #include <net/bpf.h> 93 #include <net/bpfdesc.h> 94 95 #include <sys/cpu.h> 96 #include <sys/bus.h> 97 #include <sys/intr.h> 98 99 #include <dev/pcmcia/pcmciareg.h> 100 #include <dev/pcmcia/pcmciavar.h> 101 #include <dev/pcmcia/pcmciadevs.h> 102 103 #include <dev/pcmcia/if_rayreg.h> 104 105 #define RAY_DEBUG 106 107 #ifndef RAY_PID_COUNTRY_CODE_DEFAULT 108 #define RAY_PID_COUNTRY_CODE_DEFAULT RAY_PID_COUNTRY_CODE_USA 109 #endif 110 111 /* amount of time to poll for non-return of certain command status */ 112 #ifndef RAY_CHECK_CCS_TIMEOUT 113 #define RAY_CHECK_CCS_TIMEOUT (hz / 2) 114 #endif 115 116 /* ammount of time to consider start/join failed */ 117 #ifndef RAY_START_TIMEOUT 118 #define RAY_START_TIMEOUT (30 * hz) 119 #endif 120 121 /* 122 * if a command cannot execute because device is busy try later 123 * this is also done after interrupts and other command timeouts 124 * so we can use a large value safely. 125 */ 126 #ifndef RAY_CHECK_SCHED_TIMEOUT 127 #define RAY_CHECK_SCHED_TIMEOUT (hz) /* XXX 5 */ 128 #endif 129 130 #ifndef RAY_MODE_DEFAULT 131 #define RAY_MODE_DEFAULT SC_MODE_ADHOC 132 #endif 133 134 #ifndef RAY_DEF_NWID 135 #define RAY_DEF_NWID "NETWORK_NAME" 136 #endif 137 138 /* 139 * The number of times the HW is reset in 30s before disabling. 140 * This is needed because resets take ~2s and currently pcmcia 141 * spins for the reset. 142 */ 143 #ifndef RAY_MAX_RESETS 144 #define RAY_MAX_RESETS 3 145 #endif 146 147 /* 148 * Types 149 */ 150 151 struct ray_softc { 152 device_t sc_dev; 153 struct ethercom sc_ec; 154 struct ifmedia sc_media; 155 156 struct pcmcia_function *sc_pf; 157 void *sc_ih; 158 int sc_attached; 159 160 int sc_resetloop; 161 162 struct callout sc_check_ccs_ch; 163 struct callout sc_check_scheduled_ch; 164 struct callout sc_reset_resetloop_ch; 165 struct callout sc_disable_ch; 166 struct callout sc_start_join_timo_ch; 167 168 struct ray_ecf_startup sc_ecf_startup; 169 struct ray_startup_params_head sc_startup; 170 union { 171 struct ray_startup_params_tail_5 u_params_5; 172 struct ray_startup_params_tail_4 u_params_4; 173 } sc_u; 174 175 u_int8_t sc_ccsinuse[64]; /* ccs in use -- not for tx */ 176 u_int sc_txfree; /* a free count for efficiency */ 177 178 u_int8_t sc_bssid[ETHER_ADDR_LEN]; /* current net values */ 179 u_int8_t sc_authid[ETHER_ADDR_LEN]; /* ID of authenticating 180 station */ 181 struct ieee80211_nwid sc_cnwid; /* last nwid */ 182 struct ieee80211_nwid sc_dnwid; /* desired nwid */ 183 u_int8_t sc_omode; /* old operating mode SC_MODE_xx */ 184 u_int8_t sc_mode; /* current operating mode SC_MODE_xx */ 185 u_int8_t sc_countrycode; /* current country code */ 186 u_int8_t sc_dcountrycode; /* desired country code */ 187 int sc_havenet; /* true if we have acquired a network */ 188 bus_size_t sc_txpad; /* tib size plus "phy" size */ 189 u_int8_t sc_deftxrate; /* default transfer rate */ 190 u_int8_t sc_encrypt; 191 u_int8_t sc_authstate; /* authentication state */ 192 193 int sc_promisc; /* current set value */ 194 int sc_running; /* things we are doing */ 195 int sc_scheduled; /* things we need to do */ 196 int sc_timoneed; /* set if timeout is sched */ 197 int sc_timocheck; /* set if timeout is sched */ 198 bus_size_t sc_startccs; /* ccs of start/join */ 199 u_int sc_startcmd; /* cmd (start | join) */ 200 201 int sc_checkcounters; 202 u_int64_t sc_rxoverflow; 203 u_int64_t sc_rxcksum; 204 u_int64_t sc_rxhcksum; 205 u_int8_t sc_rxnoise; 206 207 /* use to return values to the user */ 208 struct ray_param_req *sc_repreq; 209 struct ray_param_req *sc_updreq; 210 211 bus_space_tag_t sc_memt; 212 bus_space_handle_t sc_memh; 213 214 #ifdef RAY_DO_SIGLEV 215 struct ray_siglev sc_siglevs[RAY_NSIGLEVRECS]; 216 #endif 217 }; 218 #define sc_ccrt sc_pf->pf_ccrt 219 #define sc_ccrh sc_pf->pf_ccrh 220 #define sc_ccroff sc_pf->pf_ccr_offset 221 #define sc_startup_4 sc_u.u_params_4 222 #define sc_startup_5 sc_u.u_params_5 223 #define sc_version sc_ecf_startup.e_fw_build_string 224 #define sc_tibsize sc_ecf_startup.e_tib_size 225 #define sc_if sc_ec.ec_if 226 227 /* modes of operation */ 228 #define SC_MODE_ADHOC 0 /* ad-hoc mode */ 229 #define SC_MODE_INFRA 1 /* infrastructure mode */ 230 231 /* commands -- priority given to LSB */ 232 #define SCP_FIRST 0x0001 233 #define SCP_UPDATESUBCMD 0x0001 234 #define SCP_STARTASSOC 0x0002 235 #define SCP_REPORTPARAMS 0x0004 236 #define SCP_IFSTART 0x0008 237 238 /* update sub commands -- issues are serialized priority to LSB */ 239 #define SCP_UPD_FIRST 0x0100 240 #define SCP_UPD_STARTUP 0x0100 241 #define SCP_UPD_STARTJOIN 0x0200 242 #define SCP_UPD_PROMISC 0x0400 243 #define SCP_UPD_MCAST 0x0800 244 #define SCP_UPD_UPDATEPARAMS 0x1000 245 #define SCP_UPD_SHIFT 8 246 #define SCP_UPD_MASK 0xff00 247 248 /* these command (a subset of the update set) require timeout checking */ 249 #define SCP_TIMOCHECK_CMD_MASK \ 250 (SCP_UPD_UPDATEPARAMS | SCP_UPD_STARTUP | SCP_UPD_MCAST | \ 251 SCP_UPD_PROMISC) 252 253 254 #define IFM_ADHOC \ 255 IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_FH2, IFM_IEEE80211_ADHOC, 0) 256 #define IFM_INFRA \ 257 IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_FH2, 0, 0) 258 259 typedef void (*ray_cmd_func_t)(struct ray_softc *); 260 261 #define SC_BUILD_5 0x5 262 #define SC_BUILD_4 0x55 263 264 /* sc_authstate */ 265 #define RAY_AUTH_UNAUTH 0 266 #define RAY_AUTH_WAITING 1 267 #define RAY_AUTH_AUTH 2 268 #define RAY_AUTH_NEEDED 3 269 270 #define OPEN_AUTH_REQUEST 1 271 #define OPEN_AUTH_RESPONSE 2 272 #define BROADCAST_DEAUTH 0xc0 273 274 static int ray_alloc_ccs(struct ray_softc *, bus_size_t *, u_int, u_int); 275 static bus_size_t ray_fill_in_tx_ccs(struct ray_softc *, size_t, 276 u_int, u_int); 277 static int ray_validate_config(struct pcmcia_config_entry *); 278 static void ray_attach(device_t, device_t, void *); 279 static ray_cmd_func_t ray_ccs_done(struct ray_softc *, bus_size_t); 280 static void ray_check_ccs(void *); 281 static void ray_check_scheduled(void *); 282 static void ray_cmd_cancel(struct ray_softc *, int); 283 static void ray_cmd_schedule(struct ray_softc *, int); 284 static void ray_cmd_ran(struct ray_softc *, int); 285 static int ray_cmd_is_running(struct ray_softc *, int); 286 static int ray_cmd_is_scheduled(struct ray_softc *, int); 287 static void ray_cmd_done(struct ray_softc *, int); 288 static int ray_detach(device_t, int); 289 static int ray_activate(device_t, enum devact); 290 static void ray_disable(struct ray_softc *); 291 static void ray_download_params(struct ray_softc *); 292 static int ray_enable(struct ray_softc *); 293 static u_int ray_find_free_tx_ccs(struct ray_softc *, u_int); 294 static u_int8_t ray_free_ccs(struct ray_softc *, bus_size_t); 295 static void ray_free_ccs_chain(struct ray_softc *, u_int); 296 static void ray_if_start(struct ifnet *); 297 static void ray_if_stop(struct ifnet *, int); 298 static int ray_init(struct ray_softc *); 299 static int ray_intr(void *); 300 static void ray_intr_start(struct ray_softc *); 301 static int ray_ioctl(struct ifnet *, u_long, void *); 302 static int ray_issue_cmd(struct ray_softc *, bus_size_t, u_int); 303 static int ray_match(device_t, cfdata_t, void *); 304 static int ray_media_change(struct ifnet *); 305 static void ray_media_status(struct ifnet *, struct ifmediareq *); 306 static ray_cmd_func_t ray_rccs_intr(struct ray_softc *, bus_size_t); 307 static void ray_read_region(struct ray_softc *, bus_size_t,void *,size_t); 308 static void ray_recv(struct ray_softc *, bus_size_t); 309 static void ray_recv_auth(struct ray_softc *, struct ieee80211_frame *); 310 static void ray_report_params(struct ray_softc *); 311 static void ray_reset(struct ray_softc *); 312 static void ray_reset_resetloop(void *); 313 static int ray_send_auth(struct ray_softc *, u_int8_t *, u_int8_t); 314 static void ray_set_pending(struct ray_softc *, u_int); 315 static int ray_simple_cmd(struct ray_softc *, u_int, u_int); 316 static void ray_start_assoc(struct ray_softc *); 317 static void ray_start_join_net(struct ray_softc *); 318 static ray_cmd_func_t ray_start_join_net_done(struct ray_softc *, 319 u_int, bus_size_t, u_int); 320 static void ray_start_join_timo(void *); 321 static void ray_stop(struct ray_softc *); 322 static void ray_update_error_counters(struct ray_softc *); 323 static void ray_update_mcast(struct ray_softc *); 324 static ray_cmd_func_t ray_update_params_done(struct ray_softc *, 325 bus_size_t, u_int); 326 static void ray_update_params(struct ray_softc *); 327 static void ray_update_promisc(struct ray_softc *); 328 static void ray_update_subcmd(struct ray_softc *); 329 static int ray_user_report_params(struct ray_softc *, 330 struct ray_param_req *); 331 static int ray_user_update_params(struct ray_softc *, 332 struct ray_param_req *); 333 static void ray_write_region(struct ray_softc *,bus_size_t,void *,size_t); 334 335 #ifdef RAY_DO_SIGLEV 336 static void ray_update_siglev(struct ray_softc *, u_int8_t *, u_int8_t); 337 #endif 338 339 #ifdef RAY_DEBUG 340 static int ray_debug = 0; 341 static int ray_debug_xmit_sum = 0; 342 static int ray_debug_dump_desc = 0; 343 static int ray_debug_dump_rx = 0; 344 static int ray_debug_dump_tx = 0; 345 static struct timeval rtv, tv1, tv2, *ttp, *ltp; 346 #define RAY_DPRINTF(x) do { if (ray_debug) { \ 347 struct timeval *ttmp; \ 348 microtime(ttp); \ 349 timersub(ttp, ltp, &rtv); \ 350 ttmp = ttp; ttp = ltp; ltp = ttmp; \ 351 printf("%ld:%ld %ld:%06ld: ", \ 352 (long int)ttp->tv_sec, \ 353 (long int)ttp->tv_usec, \ 354 (long int)rtv.tv_sec, \ 355 (long int)rtv.tv_usec); \ 356 printf x ; \ 357 } } while (0) 358 #define RAY_DPRINTF_XMIT(x) do { if (ray_debug_xmit_sum) { \ 359 struct timeval *ttmp; \ 360 microtime(ttp); \ 361 timersub(ttp, ltp, &rtv); \ 362 ttmp = ttp; ttp = ltp; ltp = ttmp; \ 363 printf("%ld:%ld %ld:%06ld: ", \ 364 (long int)ttp->tv_sec, \ 365 (long int)ttp->tv_usec, \ 366 (long int)rtv.tv_sec, \ 367 (long int)rtv.tv_usec); \ 368 printf x ; \ 369 } } while (0) 370 371 #define HEXDF_NOCOMPRESS 0x1 372 #define HEXDF_NOOFFSET 0x2 373 #define HEXDF_NOASCII 0x4 374 void hexdump(const u_int8_t *, int, int, int, int); 375 static void ray_dump_mbuf(struct ray_softc *, struct mbuf *); 376 377 #else /* !RAY_DEBUG */ 378 379 #define RAY_DPRINTF(x) 380 #define RAY_DPRINTF_XMIT(x) 381 382 #endif /* !RAY_DEBUG */ 383 384 /* 385 * macros for writing to various regions in the mapped memory space 386 */ 387 388 /* use already mapped ccrt */ 389 #define REG_WRITE(sc, off, val) \ 390 bus_space_write_1((sc)->sc_ccrt, (sc)->sc_ccrh, ((sc)->sc_ccroff + (off)), (val)) 391 392 #define REG_READ(sc, off) \ 393 bus_space_read_1((sc)->sc_ccrt, (sc)->sc_ccrh, ((sc)->sc_ccroff + (off))) 394 395 #define SRAM_READ_1(sc, off) \ 396 ((u_int8_t)bus_space_read_1((sc)->sc_memt, (sc)->sc_memh, (off))) 397 398 #define SRAM_READ_FIELD_1(sc, off, s, f) \ 399 SRAM_READ_1(sc, (off) + offsetof(struct s, f)) 400 401 #define SRAM_READ_FIELD_2(sc, off, s, f) \ 402 ((((u_int16_t)SRAM_READ_1(sc, (off) + offsetof(struct s, f)) << 8) \ 403 |(SRAM_READ_1(sc, (off) + 1 + offsetof(struct s, f))))) 404 405 #define SRAM_READ_FIELD_N(sc, off, s, f, p, n) \ 406 ray_read_region(sc, (off) + offsetof(struct s, f), (p), (n)) 407 408 #define SRAM_WRITE_1(sc, off, val) \ 409 bus_space_write_1((sc)->sc_memt, (sc)->sc_memh, (off), (val)) 410 411 #define SRAM_WRITE_FIELD_1(sc, off, s, f, v) \ 412 SRAM_WRITE_1(sc, (off) + offsetof(struct s, f), (v)) 413 414 #define SRAM_WRITE_FIELD_2(sc, off, s, f, v) do { \ 415 SRAM_WRITE_1(sc, (off) + offsetof(struct s, f), (((v) >> 8 ) & 0xff)); \ 416 SRAM_WRITE_1(sc, (off) + 1 + offsetof(struct s, f), ((v) & 0xff)); \ 417 } while (0) 418 419 #define SRAM_WRITE_FIELD_N(sc, off, s, f, p, n) \ 420 ray_write_region(sc, (off) + offsetof(struct s, f), (p), (n)) 421 422 /* 423 * Macros of general usefulness 424 */ 425 426 #define M_PULLUP(m, s) do { \ 427 if ((m)->m_len < (s)) \ 428 (m) = m_pullup((m), (s)); \ 429 } while (0) 430 431 #define RAY_ECF_READY(sc) (!(REG_READ(sc, RAY_ECFIR) & RAY_ECSIR_IRQ)) 432 #define RAY_ECF_START_CMD(sc) REG_WRITE(sc, RAY_ECFIR, RAY_ECSIR_IRQ) 433 #define RAY_GET_INDEX(ccs) (((ccs) - RAY_CCS_BASE) / RAY_CCS_SIZE) 434 #define RAY_GET_CCS(i) (RAY_CCS_BASE + (i) * RAY_CCS_SIZE) 435 436 /* 437 * Globals 438 */ 439 440 static u_int8_t llc_snapid[6] = { LLC_SNAP_LSAP, LLC_SNAP_LSAP, LLC_UI, }; 441 442 /* based on bit index in SCP_xx */ 443 static ray_cmd_func_t ray_cmdtab[] = { 444 ray_update_subcmd, /* SCP_UPDATESUBCMD */ 445 ray_start_assoc, /* SCP_STARTASSOC */ 446 ray_report_params, /* SCP_REPORTPARAMS */ 447 ray_intr_start /* SCP_IFSTART */ 448 }; 449 static int ray_ncmdtab = sizeof(ray_cmdtab) / sizeof(*ray_cmdtab); 450 451 static ray_cmd_func_t ray_subcmdtab[] = { 452 ray_download_params, /* SCP_UPD_STARTUP */ 453 ray_start_join_net, /* SCP_UPD_STARTJOIN */ 454 ray_update_promisc, /* SCP_UPD_PROMISC */ 455 ray_update_mcast, /* SCP_UPD_MCAST */ 456 ray_update_params /* SCP_UPD_UPDATEPARAMS */ 457 }; 458 static int ray_nsubcmdtab = sizeof(ray_subcmdtab) / sizeof(*ray_subcmdtab); 459 460 /* autoconf information */ 461 CFATTACH_DECL_NEW(ray, sizeof(struct ray_softc), 462 ray_match, ray_attach, ray_detach, ray_activate); 463 464 /* 465 * Config Routines 466 */ 467 468 static int 469 ray_match(device_t parent, cfdata_t match, 470 void *aux) 471 { 472 struct pcmcia_attach_args *pa = aux; 473 474 #ifdef RAY_DEBUG 475 if (!ltp) { 476 /* initialize timestamp XXX */ 477 ttp = &tv1; 478 ltp = &tv2; 479 microtime(ltp); 480 } 481 #endif 482 return (pa->manufacturer == PCMCIA_VENDOR_RAYTHEON 483 && pa->product == PCMCIA_PRODUCT_RAYTHEON_WLAN); 484 } 485 486 static int 487 ray_validate_config(struct pcmcia_config_entry *cfe) 488 { 489 if (cfe->iftype != PCMCIA_IFTYPE_IO || 490 cfe->num_memspace != 1 || 491 cfe->num_iospace != 0 || 492 cfe->memspace[0].length != RAY_SRAM_MEM_SIZE) 493 return (EINVAL); 494 return (0); 495 } 496 497 static void 498 ray_attach(device_t parent, device_t self, void *aux) 499 { 500 struct ray_softc *sc = device_private(self); 501 struct pcmcia_attach_args *pa = aux; 502 struct ifnet *ifp = &sc->sc_if; 503 struct pcmcia_config_entry *cfe; 504 struct ray_ecf_startup *ep; 505 int error; 506 507 sc->sc_dev = self; 508 sc->sc_pf = pa->pf; 509 510 /*XXXmem8|common*/ 511 error = pcmcia_function_configure(pa->pf, ray_validate_config); 512 if (error) { 513 aprint_error_dev(self, "configure failed, error=%d\n", error); 514 return; 515 } 516 517 cfe = pa->pf->cfe; 518 sc->sc_memt = cfe->memspace[0].handle.memt; 519 sc->sc_memh = cfe->memspace[0].handle.memh; 520 521 callout_init(&sc->sc_reset_resetloop_ch, 0); 522 callout_init(&sc->sc_disable_ch, 0); 523 callout_init(&sc->sc_start_join_timo_ch, 0); 524 525 error = ray_enable(sc); 526 if (error) 527 goto fail; 528 529 /* get startup results */ 530 ep = &sc->sc_ecf_startup; 531 ray_read_region(sc, RAY_ECF_TO_HOST_BASE, ep, 532 sizeof(sc->sc_ecf_startup)); 533 534 /* check to see that card initialized properly */ 535 if (ep->e_status != RAY_ECFS_CARD_OK) { 536 aprint_error_dev(self, "card failed self test: status %d\n", 537 sc->sc_ecf_startup.e_status); 538 goto fail2; 539 } 540 541 /* check firmware version */ 542 if (sc->sc_version != SC_BUILD_4 && sc->sc_version != SC_BUILD_5) { 543 aprint_error_dev(self, "unsupported firmware version %d\n", 544 ep->e_fw_build_string); 545 goto fail2; 546 } 547 548 /* clear any interrupt if present */ 549 REG_WRITE(sc, RAY_HCSIR, 0); 550 551 /* 552 * set the parameters that will survive stop/init 553 */ 554 memset(&sc->sc_dnwid, 0, sizeof(sc->sc_dnwid)); 555 sc->sc_dnwid.i_len = strlen(RAY_DEF_NWID); 556 if (sc->sc_dnwid.i_len > IEEE80211_NWID_LEN) 557 sc->sc_dnwid.i_len = IEEE80211_NWID_LEN; 558 if (sc->sc_dnwid.i_len > 0) 559 memcpy(sc->sc_dnwid.i_nwid, RAY_DEF_NWID, sc->sc_dnwid.i_len); 560 memcpy(&sc->sc_cnwid, &sc->sc_dnwid, sizeof(sc->sc_cnwid)); 561 sc->sc_omode = sc->sc_mode = RAY_MODE_DEFAULT; 562 sc->sc_countrycode = sc->sc_dcountrycode = 563 RAY_PID_COUNTRY_CODE_DEFAULT; 564 565 /* 566 * attach the interface 567 */ 568 /* The version isn't the most accurate way, but it's easy. */ 569 aprint_normal_dev(self, "firmware version %d\n", 570 sc->sc_version); 571 if (sc->sc_version != SC_BUILD_4) 572 aprint_normal_dev(self, 573 "supported rates %0x:%0x:%0x:%0x:%0x:%0x:%0x:%0x\n", 574 ep->e_rates[0], ep->e_rates[1], 575 ep->e_rates[2], ep->e_rates[3], ep->e_rates[4], 576 ep->e_rates[5], ep->e_rates[6], ep->e_rates[7]); 577 aprint_normal_dev(self, "802.11 address %s\n", 578 ether_sprintf(ep->e_station_addr)); 579 580 memcpy(ifp->if_xname, device_xname(self), IFNAMSIZ); 581 ifp->if_softc = sc; 582 ifp->if_start = ray_if_start; 583 ifp->if_stop = ray_if_stop; 584 ifp->if_ioctl = ray_ioctl; 585 ifp->if_mtu = ETHERMTU; 586 ifp->if_flags = IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST; 587 IFQ_SET_READY(&ifp->if_snd); 588 589 if_attach(ifp); 590 ether_ifattach(ifp, ep->e_station_addr); 591 /* need enough space for ieee80211_header + (snap or e2) */ 592 ifp->if_hdrlen = 593 sizeof(struct ieee80211_frame) + sizeof(struct ether_header); 594 595 ifmedia_init(&sc->sc_media, 0, ray_media_change, ray_media_status); 596 ifmedia_add(&sc->sc_media, IFM_ADHOC, 0, 0); 597 ifmedia_add(&sc->sc_media, IFM_INFRA, 0, 0); 598 if (sc->sc_mode == SC_MODE_ADHOC) 599 ifmedia_set(&sc->sc_media, IFM_ADHOC); 600 else 601 ifmedia_set(&sc->sc_media, IFM_INFRA); 602 603 if (pmf_device_register(self, NULL, NULL)) 604 pmf_class_network_register(self, ifp); 605 else 606 aprint_error_dev(self, "couldn't establish power handler\n"); 607 608 /* The attach is successful. */ 609 sc->sc_attached = 1; 610 ray_disable(sc); 611 return; 612 613 fail2: 614 ray_disable(sc); 615 fail: 616 pcmcia_function_unconfigure(pa->pf); 617 } 618 619 static int 620 ray_activate(device_t self, enum devact act) 621 { 622 struct ray_softc *sc = device_private(self); 623 struct ifnet *ifp = &sc->sc_if; 624 625 RAY_DPRINTF(("%s: activate\n", device_xname(self))); 626 627 switch (act) { 628 case DVACT_DEACTIVATE: 629 if_deactivate(ifp); 630 return 0; 631 default: 632 return EOPNOTSUPP; 633 } 634 } 635 636 static int 637 ray_detach(device_t self, int flags) 638 { 639 struct ray_softc *sc; 640 struct ifnet *ifp; 641 642 sc = device_private(self); 643 ifp = &sc->sc_if; 644 RAY_DPRINTF(("%s: detach\n", device_xname(sc->sc_dev))); 645 646 if (!sc->sc_attached) 647 return (0); 648 649 pmf_device_deregister(self); 650 651 if (sc->sc_if.if_flags & IFF_UP) 652 ray_disable(sc); 653 654 ifmedia_delete_instance(&sc->sc_media, IFM_INST_ANY); 655 ether_ifdetach(ifp); 656 if_detach(ifp); 657 658 pcmcia_function_unconfigure(sc->sc_pf); 659 660 return (0); 661 } 662 663 /* 664 * start the card running 665 */ 666 static int 667 ray_enable(struct ray_softc *sc) 668 { 669 int error; 670 671 RAY_DPRINTF(("%s: enable\n", device_xname(sc->sc_dev))); 672 673 sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_NET, ray_intr, sc); 674 if (!sc->sc_ih) 675 return (EIO); 676 677 error = ray_init(sc); 678 if (error) { 679 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih); 680 sc->sc_ih = 0; 681 } 682 683 return (error); 684 } 685 686 /* 687 * stop the card running 688 */ 689 static void 690 ray_disable(struct ray_softc *sc) 691 { 692 RAY_DPRINTF(("%s: disable\n", device_xname(sc->sc_dev))); 693 694 ray_stop(sc); 695 696 sc->sc_resetloop = 0; 697 sc->sc_rxoverflow = 0; 698 sc->sc_rxcksum = 0; 699 sc->sc_rxhcksum = 0; 700 sc->sc_rxnoise = 0; 701 702 if (sc->sc_ih) { 703 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih); 704 sc->sc_ih = 0; 705 } 706 } 707 708 /* 709 * start the card running 710 */ 711 static int 712 ray_init(struct ray_softc *sc) 713 { 714 struct ray_ecf_startup *ep; 715 bus_size_t ccs; 716 int i; 717 718 RAY_DPRINTF(("%s: init\n", device_xname(sc->sc_dev))); 719 720 if ((sc->sc_if.if_flags & IFF_RUNNING)) 721 ray_stop(sc); 722 723 if (pcmcia_function_enable(sc->sc_pf)) 724 return (EIO); 725 726 RAY_DPRINTF(("%s: init post-enable\n", device_xname(sc->sc_dev))); 727 728 /* reset some values */ 729 memset(sc->sc_ccsinuse, 0, sizeof(sc->sc_ccsinuse)); 730 sc->sc_havenet = 0; 731 memset(sc->sc_bssid, 0, sizeof(sc->sc_bssid)); 732 sc->sc_deftxrate = 0; 733 sc->sc_encrypt = 0; 734 sc->sc_txpad = 0; 735 sc->sc_promisc = 0; 736 sc->sc_scheduled = 0; 737 sc->sc_running = 0; 738 sc->sc_txfree = RAY_CCS_NTX; 739 sc->sc_checkcounters = 0; 740 sc->sc_authstate = RAY_AUTH_UNAUTH; 741 742 /* get startup results */ 743 ep = &sc->sc_ecf_startup; 744 ray_read_region(sc, RAY_ECF_TO_HOST_BASE, ep, 745 sizeof(sc->sc_ecf_startup)); 746 747 /* check to see that card initialized properly */ 748 if (ep->e_status != RAY_ECFS_CARD_OK) { 749 pcmcia_function_disable(sc->sc_pf); 750 printf("%s: card failed self test: status %d\n", 751 device_xname(sc->sc_dev), sc->sc_ecf_startup.e_status); 752 return (EIO); 753 } 754 755 /* fixup tib size to be correct */ 756 if (sc->sc_version == SC_BUILD_4 && sc->sc_tibsize == 0x55) 757 sc->sc_tibsize = 32; 758 sc->sc_txpad = sc->sc_tibsize; 759 760 /* set all ccs to be free */ 761 ccs = RAY_GET_CCS(0); 762 for (i = 0; i < RAY_CCS_LAST; ccs += RAY_CCS_SIZE, i++) 763 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, 764 RAY_CCS_STATUS_FREE); 765 766 /* clear the interrupt if present */ 767 REG_WRITE(sc, RAY_HCSIR, 0); 768 769 callout_init(&sc->sc_check_ccs_ch, 0); 770 callout_init(&sc->sc_check_scheduled_ch, 0); 771 772 /* we are now up and running -- and are busy until download is cplt */ 773 sc->sc_if.if_flags |= IFF_RUNNING | IFF_OACTIVE; 774 775 /* set this now so it gets set in the download */ 776 if (sc->sc_if.if_flags & IFF_ALLMULTI) 777 sc->sc_if.if_flags |= IFF_PROMISC; 778 else if (sc->sc_if.if_pcount == 0) 779 sc->sc_if.if_flags &= ~IFF_PROMISC; 780 sc->sc_promisc = !!(sc->sc_if.if_flags & IFF_PROMISC); 781 782 /* call after we mark ourselves running */ 783 ray_download_params(sc); 784 785 return (0); 786 } 787 788 /* 789 * stop the card running 790 */ 791 static void 792 ray_stop(struct ray_softc *sc) 793 { 794 RAY_DPRINTF(("%s: stop\n", device_xname(sc->sc_dev))); 795 796 callout_stop(&sc->sc_check_ccs_ch); 797 sc->sc_timocheck = 0; 798 799 callout_stop(&sc->sc_check_scheduled_ch); 800 sc->sc_timoneed = 0; 801 802 if (sc->sc_repreq) { 803 sc->sc_repreq->r_failcause = RAY_FAILCAUSE_EDEVSTOP; 804 wakeup(ray_report_params); 805 } 806 if (sc->sc_updreq) { 807 sc->sc_updreq->r_failcause = RAY_FAILCAUSE_EDEVSTOP; 808 wakeup(ray_update_params); 809 } 810 811 sc->sc_if.if_flags &= ~IFF_RUNNING; 812 pcmcia_function_disable(sc->sc_pf); 813 } 814 815 /* 816 * reset the card 817 */ 818 static void 819 ray_reset(struct ray_softc *sc) 820 { 821 if (++sc->sc_resetloop >= RAY_MAX_RESETS) { 822 if (sc->sc_resetloop == RAY_MAX_RESETS) { 823 aprint_error_dev(sc->sc_dev, 824 "unable to correct, disabling\n"); 825 callout_stop(&sc->sc_reset_resetloop_ch); 826 callout_reset(&sc->sc_disable_ch, 1, 827 (void (*)(void *))ray_disable, sc); 828 } 829 } else { 830 aprint_error_dev(sc->sc_dev, 831 "unexpected failure resetting hw [%d more]\n", 832 RAY_MAX_RESETS - sc->sc_resetloop); 833 callout_stop(&sc->sc_reset_resetloop_ch); 834 ray_init(sc); 835 callout_reset(&sc->sc_reset_resetloop_ch, 30 * hz, 836 ray_reset_resetloop, sc); 837 } 838 } 839 840 /* 841 * return resetloop to zero (enough time has expired to allow user to 842 * disable a whacked interface) the main reason for all this nonesense 843 * is that resets take ~2 seconds and currently the pcmcia code spins 844 * on these resets 845 */ 846 static void 847 ray_reset_resetloop(void *arg) 848 { 849 struct ray_softc *sc; 850 851 sc = arg; 852 sc->sc_resetloop = 0; 853 } 854 855 static int 856 ray_ioctl(struct ifnet *ifp, u_long cmd, void *data) 857 { 858 struct ieee80211_nwid nwid; 859 struct ray_param_req pr; 860 struct ray_softc *sc; 861 struct ifreq *ifr; 862 struct ifaddr *ifa; 863 int error, error2, s, i; 864 865 sc = ifp->if_softc; 866 error = 0; 867 868 ifr = (struct ifreq *)data; 869 870 s = splnet(); 871 872 RAY_DPRINTF(("%s: ioctl: cmd 0x%lx data 0x%lx\n", ifp->if_xname, 873 cmd, (long)data)); 874 switch (cmd) { 875 case SIOCINITIFADDR: 876 RAY_DPRINTF(("%s: ioctl: cmd SIOCINITIFADDR\n", ifp->if_xname)); 877 if ((ifp->if_flags & IFF_RUNNING) == 0) 878 if ((error = ray_enable(sc))) 879 break; 880 ifp->if_flags |= IFF_UP; 881 ifa = (struct ifaddr *)data; 882 switch (ifa->ifa_addr->sa_family) { 883 #ifdef INET 884 case AF_INET: 885 arp_ifinit(&sc->sc_if, ifa); 886 break; 887 #endif 888 default: 889 break; 890 } 891 break; 892 case SIOCSIFFLAGS: 893 RAY_DPRINTF(("%s: ioctl: cmd SIOCSIFFLAGS\n", ifp->if_xname)); 894 if ((error = ifioctl_common(ifp, cmd, data)) != 0) 895 break; 896 if (ifp->if_flags & IFF_UP) { 897 if ((ifp->if_flags & IFF_RUNNING) == 0) { 898 if ((error = ray_enable(sc))) 899 break; 900 } else 901 ray_update_promisc(sc); 902 } else if (ifp->if_flags & IFF_RUNNING) 903 ray_disable(sc); 904 break; 905 case SIOCADDMULTI: 906 RAY_DPRINTF(("%s: ioctl: cmd SIOCADDMULTI\n", ifp->if_xname)); 907 case SIOCDELMULTI: 908 if (cmd == SIOCDELMULTI) 909 RAY_DPRINTF(("%s: ioctl: cmd SIOCDELMULTI\n", 910 ifp->if_xname)); 911 if ((error = ether_ioctl(ifp, cmd, data)) == ENETRESET) { 912 if (ifp->if_flags & IFF_RUNNING) 913 ray_update_mcast(sc); 914 error = 0; 915 } 916 break; 917 case SIOCSIFMEDIA: 918 RAY_DPRINTF(("%s: ioctl: cmd SIOCSIFMEDIA\n", ifp->if_xname)); 919 case SIOCGIFMEDIA: 920 if (cmd == SIOCGIFMEDIA) 921 RAY_DPRINTF(("%s: ioctl: cmd SIOCGIFMEDIA\n", 922 ifp->if_xname)); 923 error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd); 924 break; 925 case SIOCSRAYPARAM: 926 RAY_DPRINTF(("%s: ioctl: cmd SIOCSRAYPARAM\n", ifp->if_xname)); 927 if ((error = copyin(ifr->ifr_data, &pr, sizeof(pr)))) 928 break; 929 /* disallow certain command that have another interface */ 930 switch (pr.r_paramid) { 931 case RAY_PID_NET_TYPE: /* through media opt */ 932 case RAY_PID_AP_STATUS: /* unsupported */ 933 case RAY_PID_SSID: /* use SIOC80211[GS]NWID */ 934 case RAY_PID_MAC_ADDR: /* XXX need interface? */ 935 case RAY_PID_PROMISC: /* bpf */ 936 error = EINVAL; 937 break; 938 } 939 error = ray_user_update_params(sc, &pr); 940 error2 = copyout(&pr, ifr->ifr_data, sizeof(pr)); 941 error = error2 ? error2 : error; 942 break; 943 case SIOCGRAYPARAM: 944 RAY_DPRINTF(("%s: ioctl: cmd SIOCGRAYPARAM\n", ifp->if_xname)); 945 if ((error = copyin(ifr->ifr_data, &pr, sizeof(pr)))) 946 break; 947 error = ray_user_report_params(sc, &pr); 948 error2 = copyout(&pr, ifr->ifr_data, sizeof(pr)); 949 error = error2 ? error2 : error; 950 break; 951 case SIOCS80211NWID: 952 RAY_DPRINTF(("%s: ioctl: cmd SIOCS80211NWID\n", ifp->if_xname)); 953 /* 954 * if later people overwrite thats ok -- the latest version 955 * will always get start/joined even if it was set by 956 * a previous command 957 */ 958 if ((error = copyin(ifr->ifr_data, &nwid, sizeof(nwid)))) 959 break; 960 if (nwid.i_len > IEEE80211_NWID_LEN) { 961 error = EINVAL; 962 break; 963 } 964 /* clear trailing garbages */ 965 for (i = nwid.i_len; i < IEEE80211_NWID_LEN; i++) 966 nwid.i_nwid[i] = 0; 967 if (!memcmp(&sc->sc_dnwid, &nwid, sizeof(nwid))) 968 break; 969 memcpy(&sc->sc_dnwid, &nwid, sizeof(nwid)); 970 if (ifp->if_flags & IFF_RUNNING) 971 ray_start_join_net(sc); 972 break; 973 case SIOCG80211NWID: 974 RAY_DPRINTF(("%s: ioctl: cmd SIOCG80211NWID\n", ifp->if_xname)); 975 error = copyout(&sc->sc_cnwid, ifr->ifr_data, 976 sizeof(sc->sc_cnwid)); 977 break; 978 #ifdef RAY_DO_SIGLEV 979 case SIOCGRAYSIGLEV: 980 error = copyout(sc->sc_siglevs, ifr->ifr_data, 981 sizeof sc->sc_siglevs); 982 break; 983 #endif 984 default: 985 RAY_DPRINTF(("%s: ioctl: unknown\n", ifp->if_xname)); 986 error = ether_ioctl(ifp, cmd, data); 987 break; 988 } 989 990 RAY_DPRINTF(("%s: ioctl: returns %d\n", ifp->if_xname, error)); 991 992 splx(s); 993 994 return (error); 995 } 996 997 /* 998 * ifnet interface to start transmission on the interface 999 */ 1000 static void 1001 ray_if_start(struct ifnet *ifp) 1002 { 1003 struct ray_softc *sc; 1004 1005 sc = ifp->if_softc; 1006 ray_intr_start(sc); 1007 } 1008 1009 static void 1010 ray_if_stop(struct ifnet *ifp, int disable) 1011 { 1012 struct ray_softc *sc = ifp->if_softc; 1013 1014 ray_stop(sc); 1015 } 1016 1017 static int 1018 ray_media_change(struct ifnet *ifp) 1019 { 1020 struct ray_softc *sc; 1021 1022 sc = ifp->if_softc; 1023 RAY_DPRINTF(("%s: media change cur %d\n", ifp->if_xname, 1024 sc->sc_media.ifm_cur->ifm_media)); 1025 if (sc->sc_media.ifm_cur->ifm_media & IFM_IEEE80211_ADHOC) 1026 sc->sc_mode = SC_MODE_ADHOC; 1027 else 1028 sc->sc_mode = SC_MODE_INFRA; 1029 if (sc->sc_mode != sc->sc_omode) 1030 ray_start_join_net(sc); 1031 return (0); 1032 } 1033 1034 static void 1035 ray_media_status(struct ifnet *ifp, struct ifmediareq *imr) 1036 { 1037 struct ray_softc *sc; 1038 1039 sc = ifp->if_softc; 1040 1041 RAY_DPRINTF(("%s: media status\n", ifp->if_xname)); 1042 1043 imr->ifm_status = IFM_AVALID; 1044 if (sc->sc_havenet) 1045 imr->ifm_status |= IFM_ACTIVE; 1046 1047 if (sc->sc_mode == SC_MODE_ADHOC) 1048 imr->ifm_active = IFM_ADHOC; 1049 else 1050 imr->ifm_active = IFM_INFRA; 1051 } 1052 1053 /* 1054 * called to start from ray_intr. We don't check for pending 1055 * interrupt as a result 1056 */ 1057 static void 1058 ray_intr_start(struct ray_softc *sc) 1059 { 1060 struct ieee80211_frame *iframe; 1061 struct ether_header *eh; 1062 size_t len, pktlen, tmplen; 1063 bus_size_t bufp, ebufp; 1064 struct mbuf *m0, *m; 1065 struct ifnet *ifp; 1066 u_int firsti, hinti, previ, i, pcount; 1067 u_int16_t et; 1068 u_int8_t *d; 1069 1070 ifp = &sc->sc_if; 1071 1072 RAY_DPRINTF(("%s: start free %d\n", 1073 ifp->if_xname, sc->sc_txfree)); 1074 1075 ray_cmd_cancel(sc, SCP_IFSTART); 1076 1077 if ((ifp->if_flags & IFF_RUNNING) == 0 || !sc->sc_havenet) 1078 return; 1079 1080 if (IFQ_IS_EMPTY(&ifp->if_snd)) 1081 return; 1082 1083 firsti = i = previ = RAY_CCS_LINK_NULL; 1084 hinti = RAY_CCS_TX_FIRST; 1085 1086 if (!RAY_ECF_READY(sc)) { 1087 ray_cmd_schedule(sc, SCP_IFSTART); 1088 return; 1089 } 1090 1091 /* Check to see if we need to authenticate before sending packets. */ 1092 if (sc->sc_authstate == RAY_AUTH_NEEDED) { 1093 RAY_DPRINTF(("%s: Sending auth request.\n", ifp->if_xname)); 1094 sc->sc_authstate = RAY_AUTH_WAITING; 1095 ray_send_auth(sc, sc->sc_authid, OPEN_AUTH_REQUEST); 1096 return; 1097 } 1098 1099 pcount = 0; 1100 for (;;) { 1101 /* if we have no descriptors be done */ 1102 if (i == RAY_CCS_LINK_NULL) { 1103 i = ray_find_free_tx_ccs(sc, hinti); 1104 if (i == RAY_CCS_LINK_NULL) { 1105 RAY_DPRINTF(("%s: no descriptors.\n", 1106 ifp->if_xname)); 1107 ifp->if_flags |= IFF_OACTIVE; 1108 break; 1109 } 1110 } 1111 1112 IFQ_DEQUEUE(&ifp->if_snd, m0); 1113 if (!m0) { 1114 RAY_DPRINTF(("%s: dry queue.\n", ifp->if_xname)); 1115 break; 1116 } 1117 RAY_DPRINTF(("%s: gotmbuf 0x%lx\n", ifp->if_xname, (long)m0)); 1118 pktlen = m0->m_pkthdr.len; 1119 if (pktlen > ETHER_MAX_LEN - ETHER_CRC_LEN) { 1120 RAY_DPRINTF(( 1121 "%s: mbuf too long %ld\n", ifp->if_xname, 1122 (u_long)pktlen)); 1123 ifp->if_oerrors++; 1124 m_freem(m0); 1125 continue; 1126 } 1127 RAY_DPRINTF(("%s: mbuf.m_pkthdr.len %d\n", ifp->if_xname, 1128 (int)pktlen)); 1129 1130 /* we need the ether_header now for pktlen adjustments */ 1131 M_PULLUP(m0, sizeof(struct ether_header)); 1132 if (!m0) { 1133 RAY_DPRINTF(( "%s: couldn\'t pullup ether header\n", 1134 ifp->if_xname)); 1135 ifp->if_oerrors++; 1136 continue; 1137 } 1138 RAY_DPRINTF(("%s: got pulled up mbuf 0x%lx\n", ifp->if_xname, 1139 (long)m0)); 1140 1141 /* first peek at the type of packet and figure out what to do */ 1142 eh = mtod(m0, struct ether_header *); 1143 et = ntohs(eh->ether_type); 1144 if (ifp->if_flags & IFF_LINK0) { 1145 /* don't support llc for windows compat operation */ 1146 if (et <= ETHERMTU) { 1147 m_freem(m0); 1148 ifp->if_oerrors++; 1149 continue; 1150 } 1151 tmplen = sizeof(struct ieee80211_frame); 1152 } else if (et > ETHERMTU) { 1153 /* adjust for LLC/SNAP header */ 1154 tmplen = sizeof(struct ieee80211_frame) 1155 - ETHER_ADDR_LEN; 1156 } else { 1157 tmplen = 0; 1158 } 1159 /* now get our space for the 802.11 frame */ 1160 M_PREPEND(m0, tmplen, M_DONTWAIT); 1161 if (m0) 1162 M_PULLUP(m0, sizeof(struct ether_header) + tmplen); 1163 if (!m0) { 1164 RAY_DPRINTF(("%s: couldn\'t prepend header\n", 1165 ifp->if_xname)); 1166 ifp->if_oerrors++; 1167 continue; 1168 } 1169 /* copy the frame into the mbuf for tapping */ 1170 iframe = mtod(m0, struct ieee80211_frame *); 1171 eh = (struct ether_header *)((u_int8_t *)iframe + tmplen); 1172 iframe->i_fc[0] = 1173 (IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_DATA); 1174 if (sc->sc_mode == SC_MODE_ADHOC) { 1175 iframe->i_fc[1] = IEEE80211_FC1_DIR_NODS; 1176 memcpy(iframe->i_addr1, eh->ether_dhost,ETHER_ADDR_LEN); 1177 memcpy(iframe->i_addr2, eh->ether_shost,ETHER_ADDR_LEN); 1178 memcpy(iframe->i_addr3, sc->sc_bssid, ETHER_ADDR_LEN); 1179 } else { 1180 iframe->i_fc[1] = IEEE80211_FC1_DIR_TODS; 1181 memcpy(iframe->i_addr1, sc->sc_bssid,ETHER_ADDR_LEN); 1182 memcpy(iframe->i_addr2, eh->ether_shost,ETHER_ADDR_LEN); 1183 memmove(iframe->i_addr3,eh->ether_dhost,ETHER_ADDR_LEN); 1184 } 1185 iframe->i_dur[0] = iframe->i_dur[1] = 0; 1186 iframe->i_seq[0] = iframe->i_seq[1] = 0; 1187 1188 /* if not using crummy E2 in 802.11 make it LLC/SNAP */ 1189 if ((ifp->if_flags & IFF_LINK0) == 0 && et > ETHERMTU) 1190 memcpy(iframe + 1, llc_snapid, sizeof(llc_snapid)); 1191 1192 RAY_DPRINTF(("%s: i %d previ %d\n", ifp->if_xname, i, previ)); 1193 1194 if (firsti == RAY_CCS_LINK_NULL) 1195 firsti = i; 1196 1197 pktlen = m0->m_pkthdr.len; 1198 bufp = ray_fill_in_tx_ccs(sc, pktlen, i, previ); 1199 previ = hinti = i; 1200 i = RAY_CCS_LINK_NULL; 1201 1202 RAY_DPRINTF(("%s: bufp 0x%lx new pktlen %d\n", 1203 ifp->if_xname, (long)bufp, (int)pktlen)); 1204 1205 /* copy out mbuf */ 1206 for (m = m0; m; m = m->m_next) { 1207 if ((len = m->m_len) == 0) 1208 continue; 1209 RAY_DPRINTF(( 1210 "%s: copying mbuf 0x%lx bufp 0x%lx len %d\n", 1211 ifp->if_xname, (long)m, (long)bufp, (int)len)); 1212 d = mtod(m, u_int8_t *); 1213 ebufp = bufp + len; 1214 if (ebufp <= RAY_TX_END) 1215 ray_write_region(sc, bufp, d, len); 1216 else { 1217 panic("ray_intr_start"); /* XXX */ 1218 /* wrapping */ 1219 tmplen = ebufp - bufp; 1220 len -= tmplen; 1221 ray_write_region(sc, bufp, d, tmplen); 1222 d += tmplen; 1223 bufp = RAY_TX_BASE; 1224 ray_write_region(sc, bufp, d, len); 1225 } 1226 bufp += len; 1227 } 1228 if (ifp->if_bpf) { 1229 if (ifp->if_flags & IFF_LINK0) { 1230 m0->m_data += sizeof(struct ieee80211_frame); 1231 m0->m_len -= sizeof(struct ieee80211_frame); 1232 m0->m_pkthdr.len -= sizeof(struct ieee80211_frame); 1233 } 1234 bpf_mtap(ifp, m0); 1235 if (ifp->if_flags & IFF_LINK0) { 1236 m0->m_data -= sizeof(struct ieee80211_frame); 1237 m0->m_len += sizeof(struct ieee80211_frame); 1238 m0->m_pkthdr.len += sizeof(struct ieee80211_frame); 1239 } 1240 } 1241 1242 #ifdef RAY_DEBUG 1243 if (ray_debug && ray_debug_dump_tx) 1244 ray_dump_mbuf(sc, m0); 1245 #endif 1246 pcount++; 1247 m_freem(m0); 1248 1249 RAY_DPRINTF_XMIT(("%s: sent packet: len %ld\n", 1250 device_xname(sc->sc_dev), (u_long)pktlen)); 1251 } 1252 1253 if (firsti == RAY_CCS_LINK_NULL) 1254 return; 1255 i = 0; 1256 if (!RAY_ECF_READY(sc)) { 1257 /* 1258 * if this can really happen perhaps we need to save 1259 * the chain and use it later. I think this might 1260 * be a confused state though because we check above 1261 * and don't issue any commands between. 1262 */ 1263 printf("%s: dropping tx packets device busy\n", 1264 device_xname(sc->sc_dev)); 1265 ray_free_ccs_chain(sc, firsti); 1266 ifp->if_oerrors += pcount; 1267 return; 1268 } 1269 1270 /* send it off */ 1271 RAY_DPRINTF(("%s: ray_start issuing %d \n", device_xname(sc->sc_dev), 1272 firsti)); 1273 SRAM_WRITE_1(sc, RAY_SCB_CCSI, firsti); 1274 RAY_ECF_START_CMD(sc); 1275 1276 ifp->if_opackets += pcount; 1277 } 1278 1279 /* 1280 * recevice a packet from the card 1281 */ 1282 static void 1283 ray_recv(struct ray_softc *sc, bus_size_t ccs) 1284 { 1285 struct ieee80211_frame *frame; 1286 struct ether_header *eh; 1287 struct mbuf *m; 1288 size_t pktlen, fudge, len, lenread = 0; 1289 bus_size_t bufp, ebufp, tmp; 1290 struct ifnet *ifp; 1291 u_int8_t *src, *d; 1292 u_int frag = 0, ni, i, issnap, first; 1293 u_int8_t fc0; 1294 #ifdef RAY_DO_SIGLEV 1295 u_int8_t siglev; 1296 #endif 1297 1298 #ifdef RAY_DEBUG 1299 /* have a look if you want to see how the card rx works :) */ 1300 if (ray_debug && ray_debug_dump_desc) 1301 hexdump((char *)sc->sc_memh + RAY_RCS_BASE, 0x400, 16, 4, 0); 1302 #endif 1303 1304 m = 0; 1305 ifp = &sc->sc_if; 1306 1307 /* 1308 * If we're expecting the E2-in-802.11 encapsulation that the 1309 * WebGear Windows driver produces, fudge the packet forward 1310 * in the mbuf by 2 bytes so that the payload after the 1311 * Ethernet header will be aligned. If we end up getting a 1312 * packet that's not of this type, we'll just drop it anyway. 1313 */ 1314 if (ifp->if_flags & IFF_LINK0) 1315 fudge = 2; 1316 else 1317 fudge = 0; 1318 1319 /* it looks like at least with build 4 there is no CRC in length */ 1320 first = RAY_GET_INDEX(ccs); 1321 pktlen = SRAM_READ_FIELD_2(sc, ccs, ray_cmd_rx, c_pktlen); 1322 #ifdef RAY_DO_SIGLEV 1323 siglev = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_rx, c_siglev); 1324 #endif 1325 1326 RAY_DPRINTF(("%s: recv pktlen %ld frag %d\n", device_xname(sc->sc_dev), 1327 (u_long)pktlen, frag)); 1328 RAY_DPRINTF_XMIT(("%s: received packet: len %ld\n", 1329 device_xname(sc->sc_dev), (u_long)pktlen)); 1330 if (pktlen > MCLBYTES || pktlen < sizeof(*frame)) { 1331 RAY_DPRINTF(("%s: PKTLEN TOO BIG OR TOO SMALL\n", 1332 device_xname(sc->sc_dev))); 1333 ifp->if_ierrors++; 1334 goto done; 1335 } 1336 MGETHDR(m, M_DONTWAIT, MT_DATA); 1337 if (!m) { 1338 RAY_DPRINTF(("%s: MGETHDR FAILED\n", device_xname(sc->sc_dev))); 1339 ifp->if_ierrors++; 1340 goto done; 1341 } 1342 if ((pktlen + fudge) > MHLEN) { 1343 /* XXX should allow chaining? */ 1344 MCLGET(m, M_DONTWAIT); 1345 if ((m->m_flags & M_EXT) == 0) { 1346 RAY_DPRINTF(("%s: MCLGET FAILED\n", 1347 device_xname(sc->sc_dev))); 1348 ifp->if_ierrors++; 1349 m_freem(m); 1350 m = 0; 1351 goto done; 1352 } 1353 } 1354 m_set_rcvif(m, ifp); 1355 m->m_pkthdr.len = pktlen; 1356 m->m_len = pktlen; 1357 m->m_data += fudge; 1358 d = mtod(m, u_int8_t *); 1359 1360 RAY_DPRINTF(("%s: recv ccs index %d\n", device_xname(sc->sc_dev), 1361 first)); 1362 i = ni = first; 1363 while ((i = ni) && i != RAY_CCS_LINK_NULL) { 1364 ccs = RAY_GET_CCS(i); 1365 bufp = SRAM_READ_FIELD_2(sc, ccs, ray_cmd_rx, c_bufp); 1366 len = SRAM_READ_FIELD_2(sc, ccs, ray_cmd_rx, c_len); 1367 /* remove the CRC */ 1368 #if 0 1369 /* at least with build 4 no crc seems to be here */ 1370 if (frag++ == 0) 1371 len -= 4; 1372 #endif 1373 ni = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_rx, c_nextfrag); 1374 RAY_DPRINTF(( 1375 "%s: recv frag index %d len %ld bufp 0x%llx ni %d\n", 1376 device_xname(sc->sc_dev), i, (u_long)len, 1377 (unsigned long long)bufp, ni)); 1378 if (len + lenread > pktlen) { 1379 RAY_DPRINTF(("%s: BAD LEN current 0x%lx pktlen 0x%lx\n", 1380 device_xname(sc->sc_dev), (u_long)(len + lenread), 1381 (u_long)pktlen)); 1382 ifp->if_ierrors++; 1383 m_freem(m); 1384 m = 0; 1385 goto done; 1386 } 1387 if (i < RAY_RCCS_FIRST) { 1388 printf("ray_recv: bad ccs index 0x%x\n", i); 1389 m_freem(m); 1390 m = 0; 1391 goto done; 1392 } 1393 1394 ebufp = bufp + len; 1395 if (ebufp <= RAY_RX_END) 1396 ray_read_region(sc, bufp, d, len); 1397 else { 1398 /* wrapping */ 1399 ray_read_region(sc, bufp, d, (tmp = RAY_RX_END - bufp)); 1400 ray_read_region(sc, RAY_RX_BASE, d + tmp, 1401 ebufp - RAY_RX_END); 1402 } 1403 d += len; 1404 lenread += len; 1405 } 1406 done: 1407 1408 RAY_DPRINTF(("%s: recv frag count %d\n", device_xname(sc->sc_dev), 1409 frag)); 1410 1411 /* free the rcss */ 1412 ni = first; 1413 while ((i = ni) && (i != RAY_CCS_LINK_NULL)) { 1414 ccs = RAY_GET_CCS(i); 1415 ni = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_rx, c_nextfrag); 1416 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, 1417 RAY_CCS_STATUS_FREE); 1418 } 1419 1420 if (!m) 1421 return; 1422 1423 RAY_DPRINTF(("%s: recv got packet pktlen %ld actual %ld\n", 1424 device_xname(sc->sc_dev), (u_long)pktlen, (u_long)lenread)); 1425 #ifdef RAY_DEBUG 1426 if (ray_debug && ray_debug_dump_rx) 1427 ray_dump_mbuf(sc, m); 1428 #endif 1429 /* receivce the packet */ 1430 frame = mtod(m, struct ieee80211_frame *); 1431 fc0 = frame->i_fc[0] 1432 & (IEEE80211_FC0_VERSION_MASK|IEEE80211_FC0_TYPE_MASK); 1433 if ((fc0 & IEEE80211_FC0_VERSION_MASK) != IEEE80211_FC0_VERSION_0) { 1434 RAY_DPRINTF(("%s: pkt not version 0 fc 0x%x\n", 1435 device_xname(sc->sc_dev), fc0)); 1436 m_freem(m); 1437 return; 1438 } 1439 if ((fc0 & IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_MGT) { 1440 switch (frame->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) { 1441 case IEEE80211_FC0_SUBTYPE_BEACON: 1442 /* Ignore beacon silently. */ 1443 break; 1444 case IEEE80211_FC0_SUBTYPE_AUTH: 1445 ray_recv_auth(sc, frame); 1446 break; 1447 case IEEE80211_FC0_SUBTYPE_DEAUTH: 1448 sc->sc_authstate = RAY_AUTH_UNAUTH; 1449 break; 1450 default: 1451 RAY_DPRINTF(("%s: mgt packet not supported\n", 1452 device_xname(sc->sc_dev))); 1453 #ifdef RAY_DEBUG 1454 hexdump((const u_int8_t*)frame, pktlen, 16, 4, 0); 1455 #endif 1456 RAY_DPRINTF(("\n")); 1457 break; 1458 } 1459 m_freem(m); 1460 return; 1461 } else if ((fc0 & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_DATA) { 1462 RAY_DPRINTF(("%s: pkt not type data fc0 0x%x\n", 1463 device_xname(sc->sc_dev), fc0)); 1464 m_freem(m); 1465 return; 1466 } 1467 1468 if (pktlen < sizeof(*frame) + sizeof(struct llc)) { 1469 RAY_DPRINTF(("%s: pkt too small for llc (%ld)\n", 1470 device_xname(sc->sc_dev), (u_long)pktlen)); 1471 m_freem(m); 1472 return; 1473 } 1474 1475 if (!memcmp(frame + 1, llc_snapid, sizeof(llc_snapid))) 1476 issnap = 1; 1477 else { 1478 /* 1479 * if user has link0 flag set we allow the weird 1480 * Ethernet2 in 802.11 encapsulation produced by 1481 * the windows driver for the WebGear card 1482 */ 1483 RAY_DPRINTF(("%s: pkt not snap 0\n", device_xname(sc->sc_dev))); 1484 if ((ifp->if_flags & IFF_LINK0) == 0) { 1485 m_freem(m); 1486 return; 1487 } 1488 issnap = 0; 1489 } 1490 switch (frame->i_fc[1] & IEEE80211_FC1_DIR_MASK) { 1491 case IEEE80211_FC1_DIR_NODS: 1492 src = frame->i_addr2; 1493 break; 1494 case IEEE80211_FC1_DIR_FROMDS: 1495 src = frame->i_addr3; 1496 break; 1497 case IEEE80211_FC1_DIR_TODS: 1498 RAY_DPRINTF(("%s: pkt ap2ap\n", device_xname(sc->sc_dev))); 1499 m_freem(m); 1500 return; 1501 default: 1502 RAY_DPRINTF(("%s: pkt type unknown\n", 1503 device_xname(sc->sc_dev))); 1504 m_freem(m); 1505 return; 1506 } 1507 1508 #ifdef RAY_DO_SIGLEV 1509 ray_update_siglev(sc, src, siglev); 1510 #endif 1511 1512 /* 1513 * This is a mess.. we should support other LLC frame types 1514 */ 1515 if (issnap) { 1516 /* create an ether_header over top of the 802.11+SNAP header */ 1517 eh = (struct ether_header *)((char *)(frame + 1) - 6); 1518 memcpy(eh->ether_shost, src, ETHER_ADDR_LEN); 1519 memcpy(eh->ether_dhost, frame->i_addr1, ETHER_ADDR_LEN); 1520 } else { 1521 /* this is the weird e2 in 802.11 encapsulation */ 1522 eh = (struct ether_header *)(frame + 1); 1523 } 1524 m_adj(m, (char *)eh - (char *)frame); 1525 bpf_mtap(ifp, m); 1526 /* XXX doesn't appear to be included m->m_flags |= M_HASFCS; */ 1527 ifp->if_ipackets++; 1528 if_percpuq_enqueue(ifp->if_percpuq, m); 1529 } 1530 1531 /* 1532 * receive an auth packet 1533 */ 1534 static void 1535 ray_recv_auth(struct ray_softc *sc, struct ieee80211_frame *frame) 1536 { 1537 u_int8_t *var = (u_int8_t *)(frame + 1); 1538 1539 if (sc->sc_mode == SC_MODE_ADHOC) { 1540 RAY_DPRINTF(("%s: recv auth packet:\n", 1541 device_xname(sc->sc_dev))); 1542 #ifdef RAY_DEBUG 1543 hexdump((const u_int8_t *)frame, sizeof(*frame) + 6, 16, 4, 0); 1544 #endif 1545 RAY_DPRINTF(("\n")); 1546 1547 if (var[2] == OPEN_AUTH_REQUEST) { 1548 RAY_DPRINTF(("%s: Sending authentication response.\n", 1549 device_xname(sc->sc_dev))); 1550 if (ray_send_auth(sc, frame->i_addr2, 1551 OPEN_AUTH_RESPONSE) == 0) { 1552 sc->sc_authstate = RAY_AUTH_NEEDED; 1553 memcpy(sc->sc_authid, frame->i_addr2, 1554 ETHER_ADDR_LEN); 1555 } 1556 } else if (var[2] == OPEN_AUTH_RESPONSE) { 1557 RAY_DPRINTF(("%s: Authenticated!\n", 1558 device_xname(sc->sc_dev))); 1559 sc->sc_authstate = RAY_AUTH_AUTH; 1560 } 1561 } 1562 } 1563 1564 /* 1565 * send an auth packet 1566 */ 1567 static int 1568 ray_send_auth(struct ray_softc *sc, u_int8_t *dest, u_int8_t auth_type) 1569 { 1570 u_int8_t packet[sizeof(struct ieee80211_frame) + ETHER_ADDR_LEN], *var; 1571 struct ieee80211_frame *frame; 1572 bus_size_t bufp; 1573 int ccsindex; 1574 1575 ccsindex = ray_find_free_tx_ccs(sc, RAY_CCS_TX_FIRST); 1576 if (ccsindex == RAY_CCS_LINK_NULL) { 1577 RAY_DPRINTF(("%s: send auth failed -- no free tx slots\n", 1578 device_xname(sc->sc_dev))); 1579 return (ENOMEM); 1580 } 1581 1582 bufp = ray_fill_in_tx_ccs(sc, sizeof(packet), ccsindex, 1583 RAY_CCS_LINK_NULL); 1584 frame = (struct ieee80211_frame *) packet; 1585 frame->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_SUBTYPE_AUTH; 1586 frame->i_fc[1] = 0; 1587 memcpy(frame->i_addr1, dest, ETHER_ADDR_LEN); 1588 memcpy(frame->i_addr2, sc->sc_ecf_startup.e_station_addr, 1589 ETHER_ADDR_LEN); 1590 memcpy(frame->i_addr3, sc->sc_bssid, ETHER_ADDR_LEN); 1591 1592 var = (u_int8_t *)(frame + 1); 1593 memset(var, 0, ETHER_ADDR_LEN); 1594 var[2] = auth_type; 1595 1596 ray_write_region(sc, bufp, packet, sizeof(packet)); 1597 1598 SRAM_WRITE_1(sc, RAY_SCB_CCSI, ccsindex); 1599 RAY_ECF_START_CMD(sc); 1600 1601 RAY_DPRINTF_XMIT(("%s: sent auth packet: len %lu\n", 1602 device_xname(sc->sc_dev), (u_long) sizeof(packet))); 1603 1604 return (0); 1605 } 1606 1607 /* 1608 * scan for free buffers 1609 * 1610 * Note: do _not_ try to optimize this away, there is some kind of 1611 * horrible interaction with receiving tx interrupts and they 1612 * have to be done as fast as possible, which means zero processing. 1613 * this took ~ever to figure out, don't make someone do it again! 1614 */ 1615 static u_int 1616 ray_find_free_tx_ccs(struct ray_softc *sc, u_int hint) 1617 { 1618 u_int i, stat; 1619 1620 for (i = hint; i <= RAY_CCS_TX_LAST; i++) { 1621 stat = SRAM_READ_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_status); 1622 if (stat == RAY_CCS_STATUS_FREE) 1623 return (i); 1624 } 1625 1626 if (hint == RAY_CCS_TX_FIRST) 1627 return (RAY_CCS_LINK_NULL); 1628 1629 for (i = RAY_CCS_TX_FIRST; i < hint; i++) { 1630 stat = SRAM_READ_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_status); 1631 if (stat == RAY_CCS_STATUS_FREE) 1632 return (i); 1633 } 1634 return (RAY_CCS_LINK_NULL); 1635 } 1636 1637 /* 1638 * allocate, initialize and link in a tx ccs for the given 1639 * page and the current chain values 1640 */ 1641 static bus_size_t 1642 ray_fill_in_tx_ccs(struct ray_softc *sc, size_t pktlen, u_int i, u_int pi) 1643 { 1644 bus_size_t ccs, bufp; 1645 1646 /* pktlen += RAY_TX_PHY_SIZE; */ 1647 bufp = RAY_TX_BASE + i * RAY_TX_BUF_SIZE; 1648 bufp += sc->sc_txpad; 1649 ccs = RAY_GET_CCS(i); 1650 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_status, RAY_CCS_STATUS_BUSY); 1651 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_cmd, RAY_CMD_TX_REQ); 1652 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_link, RAY_CCS_LINK_NULL); 1653 SRAM_WRITE_FIELD_2(sc, ccs, ray_cmd_tx, c_bufp, bufp); 1654 SRAM_WRITE_FIELD_2(sc, ccs, ray_cmd_tx, c_len, pktlen); 1655 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_tx_rate, sc->sc_deftxrate); 1656 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_apm_mode, 0); 1657 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_antenna, 0); 1658 1659 /* link us in */ 1660 if (pi != RAY_CCS_LINK_NULL) 1661 SRAM_WRITE_FIELD_1(sc, RAY_GET_CCS(pi), ray_cmd_tx, c_link, i); 1662 1663 RAY_DPRINTF(("%s: ray_alloc_tx_ccs bufp 0x%llx idx %u pidx %u\n", 1664 device_xname(sc->sc_dev), (unsigned long long)bufp, i, pi)); 1665 1666 return (bufp + RAY_TX_PHY_SIZE); 1667 } 1668 1669 /* 1670 * an update params command has completed lookup which command and 1671 * the status 1672 */ 1673 static ray_cmd_func_t 1674 ray_update_params_done(struct ray_softc *sc, bus_size_t ccs, u_int stat) 1675 { 1676 ray_cmd_func_t rcmd; 1677 1678 rcmd = 0; 1679 1680 RAY_DPRINTF(("%s: ray_update_params_done stat %d\n", 1681 device_xname(sc->sc_dev), stat)); 1682 1683 /* this will get more complex as we add commands */ 1684 if (stat == RAY_CCS_STATUS_FAIL) { 1685 printf("%s: failed to update a promisc\n", 1686 device_xname(sc->sc_dev)); 1687 /* XXX should probably reset */ 1688 /* rcmd = ray_reset; */ 1689 } 1690 1691 if (sc->sc_running & SCP_UPD_PROMISC) { 1692 ray_cmd_done(sc, SCP_UPD_PROMISC); 1693 sc->sc_promisc = SRAM_READ_1(sc, RAY_HOST_TO_ECF_BASE); 1694 RAY_DPRINTF(("%s: new promisc value %d\n", 1695 device_xname(sc->sc_dev), sc->sc_promisc)); 1696 } else if (sc->sc_updreq) { 1697 ray_cmd_done(sc, SCP_UPD_UPDATEPARAMS); 1698 /* get the update parameter */ 1699 sc->sc_updreq->r_failcause = 1700 SRAM_READ_FIELD_1(sc, ccs, ray_cmd_update, c_failcause); 1701 sc->sc_updreq = 0; 1702 wakeup(ray_update_params); 1703 1704 rcmd = ray_start_join_net; 1705 } 1706 return (rcmd); 1707 } 1708 1709 /* 1710 * check too see if we have any pending commands. 1711 */ 1712 static void 1713 ray_check_scheduled(void *arg) 1714 { 1715 struct ray_softc *sc; 1716 int s, i, mask; 1717 1718 s = splnet(); 1719 1720 sc = arg; 1721 RAY_DPRINTF(( 1722 "%s: ray_check_scheduled enter schd 0x%x running 0x%x ready %d\n", 1723 device_xname(sc->sc_dev), sc->sc_scheduled, sc->sc_running, 1724 RAY_ECF_READY(sc))); 1725 1726 if (sc->sc_timoneed) { 1727 callout_stop(&sc->sc_check_scheduled_ch); 1728 sc->sc_timoneed = 0; 1729 } 1730 1731 /* if update subcmd is running -- clear it in scheduled */ 1732 if (sc->sc_running & SCP_UPDATESUBCMD) 1733 sc->sc_scheduled &= ~SCP_UPDATESUBCMD; 1734 1735 mask = SCP_FIRST; 1736 for (i = 0; i < ray_ncmdtab; mask <<= 1, i++) { 1737 if ((sc->sc_scheduled & ~SCP_UPD_MASK) == 0) 1738 break; 1739 if (!RAY_ECF_READY(sc)) 1740 break; 1741 if (sc->sc_scheduled & mask) 1742 (*ray_cmdtab[i])(sc); 1743 } 1744 1745 RAY_DPRINTF(( 1746 "%s: ray_check_scheduled exit sched 0x%x running 0x%x ready %d\n", 1747 device_xname(sc->sc_dev), sc->sc_scheduled, sc->sc_running, 1748 RAY_ECF_READY(sc))); 1749 1750 if (sc->sc_scheduled & ~SCP_UPD_MASK) 1751 ray_set_pending(sc, sc->sc_scheduled); 1752 1753 splx(s); 1754 } 1755 1756 /* 1757 * check for unreported returns 1758 * 1759 * this routine is coded to only expect one outstanding request for the 1760 * timed out requests at a time, but thats all that can be outstanding 1761 * per hardware limitations 1762 */ 1763 static void 1764 ray_check_ccs(void *arg) 1765 { 1766 ray_cmd_func_t fp; 1767 struct ray_softc *sc; 1768 u_int i, cmd, stat = 0; 1769 bus_size_t ccs = 0; 1770 int s; 1771 1772 s = splnet(); 1773 sc = arg; 1774 1775 RAY_DPRINTF(("%s: ray_check_ccs\n", device_xname(sc->sc_dev))); 1776 1777 sc->sc_timocheck = 0; 1778 for (i = RAY_CCS_CMD_FIRST; i <= RAY_CCS_CMD_LAST; i++) { 1779 if (!sc->sc_ccsinuse[i]) 1780 continue; 1781 ccs = RAY_GET_CCS(i); 1782 cmd = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd); 1783 switch (cmd) { 1784 case RAY_CMD_START_PARAMS: 1785 case RAY_CMD_UPDATE_MCAST: 1786 case RAY_CMD_UPDATE_PARAMS: 1787 stat = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status); 1788 RAY_DPRINTF(("%s: check ccs idx %u ccs 0x%llx " 1789 "cmd 0x%x stat %u\n", device_xname(sc->sc_dev), i, 1790 (unsigned long long)ccs, cmd, stat)); 1791 goto breakout; 1792 } 1793 } 1794 breakout: 1795 /* see if we got one of the commands we are looking for */ 1796 if (i > RAY_CCS_CMD_LAST) 1797 ; /* nothing */ 1798 else if (stat == RAY_CCS_STATUS_FREE) { 1799 stat = RAY_CCS_STATUS_COMPLETE; 1800 if ((fp = ray_ccs_done(sc, ccs))) 1801 (*fp)(sc); 1802 } else if (stat != RAY_CCS_STATUS_BUSY) { 1803 if (sc->sc_ccsinuse[i] == 1) { 1804 /* give a chance for the interrupt to occur */ 1805 sc->sc_ccsinuse[i] = 2; 1806 if (!sc->sc_timocheck) { 1807 callout_reset(&sc->sc_check_ccs_ch, 1, 1808 ray_check_ccs, sc); 1809 sc->sc_timocheck = 1; 1810 } 1811 } else if ((fp = ray_ccs_done(sc, ccs))) 1812 (*fp)(sc); 1813 } else { 1814 callout_reset(&sc->sc_check_ccs_ch, RAY_CHECK_CCS_TIMEOUT, 1815 ray_check_ccs, sc); 1816 sc->sc_timocheck = 1; 1817 } 1818 splx(s); 1819 } 1820 1821 /* 1822 * read the counters, the card implements the following protocol 1823 * to keep the values from being changed while read: It checks 1824 * the `own' bit and if zero writes the current internal counter 1825 * value, it then sets the `own' bit to 1. If the `own' bit was 1 it 1826 * increments its internal counter. The user thus reads the counter 1827 * if the `own' bit is one and then sets the own bit to 0. 1828 */ 1829 static void 1830 ray_update_error_counters(struct ray_softc *sc) 1831 { 1832 bus_size_t csc; 1833 1834 /* try and update the error counters */ 1835 csc = RAY_STATUS_BASE; 1836 if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_mrxo_own)) { 1837 sc->sc_rxoverflow += 1838 SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_mrx_overflow); 1839 SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_mrxo_own, 0); 1840 } 1841 if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_mrxc_own)) { 1842 sc->sc_rxcksum += 1843 SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_mrx_overflow); 1844 SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_mrxc_own, 0); 1845 } 1846 if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_rxhc_own)) { 1847 sc->sc_rxhcksum += 1848 SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_rx_hcksum); 1849 SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_rxhc_own, 0); 1850 } 1851 sc->sc_rxnoise = SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_rx_noise); 1852 } 1853 1854 /* 1855 * one of the commands we issued has completed, process. 1856 */ 1857 static ray_cmd_func_t 1858 ray_ccs_done(struct ray_softc *sc, bus_size_t ccs) 1859 { 1860 ray_cmd_func_t rcmd; 1861 u_int cmd, stat; 1862 1863 cmd = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd); 1864 stat = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status); 1865 1866 RAY_DPRINTF(("%s: ray_ccs_done idx %llu cmd 0x%x stat %u\n", 1867 device_xname(sc->sc_dev), (unsigned long long)RAY_GET_INDEX(ccs), 1868 cmd, stat)); 1869 1870 rcmd = 0; 1871 switch (cmd) { 1872 /* 1873 * solicited commands 1874 */ 1875 case RAY_CMD_START_PARAMS: 1876 /* start network */ 1877 ray_cmd_done(sc, SCP_UPD_STARTUP); 1878 1879 /* ok to start queueing packets */ 1880 sc->sc_if.if_flags &= ~IFF_OACTIVE; 1881 1882 sc->sc_omode = sc->sc_mode; 1883 memcpy(&sc->sc_cnwid, &sc->sc_dnwid, sizeof(sc->sc_cnwid)); 1884 1885 rcmd = ray_start_join_net; 1886 break; 1887 case RAY_CMD_UPDATE_PARAMS: 1888 rcmd = ray_update_params_done(sc, ccs, stat); 1889 break; 1890 case RAY_CMD_REPORT_PARAMS: 1891 /* get the reported parameters */ 1892 ray_cmd_done(sc, SCP_REPORTPARAMS); 1893 if (!sc->sc_repreq) 1894 break; 1895 sc->sc_repreq->r_failcause = 1896 SRAM_READ_FIELD_1(sc, ccs, ray_cmd_report, c_failcause); 1897 sc->sc_repreq->r_len = 1898 SRAM_READ_FIELD_1(sc, ccs, ray_cmd_report, c_len); 1899 ray_read_region(sc, RAY_ECF_TO_HOST_BASE, sc->sc_repreq->r_data, 1900 sc->sc_repreq->r_len); 1901 sc->sc_repreq = 0; 1902 wakeup(ray_report_params); 1903 break; 1904 case RAY_CMD_UPDATE_MCAST: 1905 ray_cmd_done(sc, SCP_UPD_MCAST); 1906 if (stat == RAY_CCS_STATUS_FAIL) 1907 rcmd = ray_reset; 1908 break; 1909 case RAY_CMD_START_NET: 1910 case RAY_CMD_JOIN_NET: 1911 rcmd = ray_start_join_net_done(sc, cmd, ccs, stat); 1912 break; 1913 case RAY_CMD_TX_REQ: 1914 if (sc->sc_if.if_flags & IFF_OACTIVE) { 1915 sc->sc_if.if_flags &= ~IFF_OACTIVE; 1916 /* this may also be a problem */ 1917 rcmd = ray_intr_start; 1918 } 1919 /* free it -- no tracking */ 1920 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, 1921 RAY_CCS_STATUS_FREE); 1922 goto done; 1923 case RAY_CMD_START_ASSOC: 1924 ray_cmd_done(sc, SCP_STARTASSOC); 1925 if (stat == RAY_CCS_STATUS_FAIL) 1926 rcmd = ray_start_join_net; /* XXX check */ 1927 else { 1928 sc->sc_havenet = 1; 1929 rcmd = ray_intr_start; 1930 } 1931 break; 1932 case RAY_CMD_UPDATE_APM: 1933 case RAY_CMD_TEST_MEM: 1934 case RAY_CMD_SHUTDOWN: 1935 case RAY_CMD_DUMP_MEM: 1936 case RAY_CMD_START_TIMER: 1937 break; 1938 default: 1939 printf("%s: intr: unknown command 0x%x\n", 1940 sc->sc_if.if_xname, cmd); 1941 break; 1942 } 1943 ray_free_ccs(sc, ccs); 1944 done: 1945 /* 1946 * see if needed things can be done now that a command 1947 * has completed 1948 */ 1949 ray_check_scheduled(sc); 1950 1951 return (rcmd); 1952 } 1953 1954 /* 1955 * an unsolicited interrupt, i.e., the ECF is sending us a command 1956 */ 1957 static ray_cmd_func_t 1958 ray_rccs_intr(struct ray_softc *sc, bus_size_t ccs) 1959 { 1960 ray_cmd_func_t rcmd; 1961 u_int cmd, stat; 1962 1963 cmd = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd); 1964 stat = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status); 1965 1966 RAY_DPRINTF(("%s: ray_rccs_intr idx %llu cmd 0x%x stat %u\n", 1967 device_xname(sc->sc_dev), (unsigned long long)RAY_GET_INDEX(ccs), 1968 cmd, stat)); 1969 1970 rcmd = 0; 1971 switch (cmd) { 1972 /* 1973 * unsolicited commands 1974 */ 1975 case RAY_ECMD_RX_DONE: 1976 ray_recv(sc, ccs); 1977 goto done; 1978 case RAY_ECMD_REJOIN_DONE: 1979 if (sc->sc_mode == SC_MODE_ADHOC) 1980 break; 1981 /* get the current ssid */ 1982 SRAM_READ_FIELD_N(sc, ccs, ray_cmd_net, c_bss_id, 1983 sc->sc_bssid, sizeof(sc->sc_bssid)); 1984 rcmd = ray_start_assoc; 1985 break; 1986 case RAY_ECMD_ROAM_START: 1987 /* no longer have network */ 1988 sc->sc_havenet = 0; 1989 break; 1990 case RAY_ECMD_JAPAN_CALL_SIGNAL: 1991 break; 1992 default: 1993 ray_update_error_counters(sc); 1994 1995 /* this is a bogus return from build 4 don't free 0x55 */ 1996 if (sc->sc_version == SC_BUILD_4 && cmd == 0x55 1997 && RAY_GET_INDEX(ccs) == 0x55) { 1998 goto done; 1999 } 2000 printf("%s: intr: unknown command 0x%x\n", 2001 sc->sc_if.if_xname, cmd); 2002 break; 2003 } 2004 /* free the ccs */ 2005 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, RAY_CCS_STATUS_FREE); 2006 done: 2007 return (rcmd); 2008 } 2009 2010 /* 2011 * process an interrupt 2012 */ 2013 static int 2014 ray_intr(void *arg) 2015 { 2016 struct ray_softc *sc; 2017 ray_cmd_func_t rcmd; 2018 u_int i, count; 2019 2020 sc = arg; 2021 2022 RAY_DPRINTF(("%s: ray_intr\n", device_xname(sc->sc_dev))); 2023 2024 if ((++sc->sc_checkcounters % 32) == 0) 2025 ray_update_error_counters(sc); 2026 2027 count = 0; 2028 rcmd = 0; 2029 if (!REG_READ(sc, RAY_HCSIR)) 2030 count = 0; 2031 else { 2032 count = 1; 2033 i = SRAM_READ_1(sc, RAY_SCB_RCCSI); 2034 if (i <= RAY_CCS_LAST) 2035 rcmd = ray_ccs_done(sc, RAY_GET_CCS(i)); 2036 else if (i <= RAY_RCCS_LAST) 2037 rcmd = ray_rccs_intr(sc, RAY_GET_CCS(i)); 2038 else 2039 printf("%s: intr: bad cmd index %d\n", 2040 device_xname(sc->sc_dev), i); 2041 } 2042 2043 if (rcmd) 2044 (*rcmd)(sc); 2045 2046 if (count) 2047 REG_WRITE(sc, RAY_HCSIR, 0); 2048 2049 RAY_DPRINTF(("%s: interrupt handled %d\n", device_xname(sc->sc_dev), 2050 count)); 2051 2052 return (count ? 1 : 0); 2053 } 2054 2055 2056 /* 2057 * Generic CCS handling 2058 */ 2059 2060 /* 2061 * free the chain of descriptors -- used for freeing allocated tx chains 2062 */ 2063 static void 2064 ray_free_ccs_chain(struct ray_softc *sc, u_int ni) 2065 { 2066 u_int i; 2067 2068 while ((i = ni) != RAY_CCS_LINK_NULL) { 2069 ni = SRAM_READ_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_link); 2070 SRAM_WRITE_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_status, 2071 RAY_CCS_STATUS_FREE); 2072 } 2073 } 2074 2075 /* 2076 * free up a cmd and return the old status 2077 * this routine is only used for commands 2078 */ 2079 static u_int8_t 2080 ray_free_ccs(struct ray_softc *sc, bus_size_t ccs) 2081 { 2082 u_int8_t stat; 2083 2084 RAY_DPRINTF(("%s: free_ccs idx %llu\n", device_xname(sc->sc_dev), 2085 (unsigned long long)RAY_GET_INDEX(ccs))); 2086 2087 stat = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status); 2088 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, RAY_CCS_STATUS_FREE); 2089 if (ccs <= RAY_GET_CCS(RAY_CCS_LAST)) 2090 sc->sc_ccsinuse[RAY_GET_INDEX(ccs)] = 0; 2091 2092 return (stat); 2093 } 2094 2095 /* 2096 * returns 1 and in `ccb' the bus offset of the free ccb 2097 * or 0 if none are free 2098 * 2099 * If `track' is not zero, handles tracking this command 2100 * possibly indicating a callback is needed and setting a timeout 2101 * also if ECF isn't ready we terminate earlier to avoid overhead. 2102 * 2103 * this routine is only used for commands 2104 */ 2105 static int 2106 ray_alloc_ccs(struct ray_softc *sc, bus_size_t *ccsp, u_int cmd, u_int track) 2107 { 2108 bus_size_t ccs; 2109 u_int i; 2110 2111 RAY_DPRINTF(("%s: alloc_ccs cmd %d\n", device_xname(sc->sc_dev), cmd)); 2112 2113 /* for tracked commands, if not ready just set pending */ 2114 if (track && !RAY_ECF_READY(sc)) { 2115 ray_cmd_schedule(sc, track); 2116 return (0); 2117 } 2118 2119 /* first scan our inuse array */ 2120 for (i = RAY_CCS_CMD_FIRST; i <= RAY_CCS_CMD_LAST; i++) { 2121 /* XXX wonder if we have to probe here to make the card go */ 2122 (void)SRAM_READ_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_status); 2123 if (!sc->sc_ccsinuse[i]) 2124 break; 2125 } 2126 if (i > RAY_CCS_CMD_LAST) { 2127 if (track) 2128 ray_cmd_schedule(sc, track); 2129 return (0); 2130 } 2131 sc->sc_ccsinuse[i] = 1; 2132 ccs = RAY_GET_CCS(i); 2133 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, RAY_CCS_STATUS_BUSY); 2134 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_cmd, cmd); 2135 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_link, RAY_CCS_LINK_NULL); 2136 2137 *ccsp = ccs; 2138 return (1); 2139 } 2140 2141 2142 /* 2143 * this function sets the pending bit for the command given in 'need' 2144 * and schedules a timeout if none is scheduled already. Any command 2145 * that uses the `host to ecf' region must be serialized. 2146 */ 2147 static void 2148 ray_set_pending(struct ray_softc *sc, u_int cmdf) 2149 { 2150 RAY_DPRINTF(("%s: ray_set_pending 0x%x\n", device_xname(sc->sc_dev), 2151 cmdf)); 2152 2153 sc->sc_scheduled |= cmdf; 2154 if (!sc->sc_timoneed) { 2155 RAY_DPRINTF(("%s: ray_set_pending new timo\n", 2156 device_xname(sc->sc_dev))); 2157 callout_reset(&sc->sc_check_scheduled_ch, 2158 RAY_CHECK_SCHED_TIMEOUT, ray_check_scheduled, sc); 2159 sc->sc_timoneed = 1; 2160 } 2161 } 2162 2163 /* 2164 * schedule the `cmdf' for completion later 2165 */ 2166 static void 2167 ray_cmd_schedule(struct ray_softc *sc, int cmdf) 2168 { 2169 int track; 2170 2171 RAY_DPRINTF(("%s: ray_cmd_schedule 0x%x\n", device_xname(sc->sc_dev), 2172 cmdf)); 2173 2174 track = cmdf; 2175 if ((cmdf & SCP_UPD_MASK) == 0) 2176 ray_set_pending(sc, track); 2177 else if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) { 2178 /* don't do timeout mechanism if subcmd already going */ 2179 sc->sc_scheduled |= cmdf; 2180 } else 2181 ray_set_pending(sc, cmdf | SCP_UPDATESUBCMD); 2182 } 2183 2184 /* 2185 * check to see if `cmdf' has been scheduled 2186 */ 2187 static int 2188 ray_cmd_is_scheduled(struct ray_softc *sc, int cmdf) 2189 { 2190 RAY_DPRINTF(("%s: ray_cmd_is_scheduled 0x%x\n", 2191 device_xname(sc->sc_dev), cmdf)); 2192 2193 return ((sc->sc_scheduled & cmdf) ? 1 : 0); 2194 } 2195 2196 /* 2197 * cancel a scheduled command (not a running one though!) 2198 */ 2199 static void 2200 ray_cmd_cancel(struct ray_softc *sc, int cmdf) 2201 { 2202 RAY_DPRINTF(("%s: ray_cmd_cancel 0x%x\n", device_xname(sc->sc_dev), 2203 cmdf)); 2204 2205 sc->sc_scheduled &= ~cmdf; 2206 if ((cmdf & SCP_UPD_MASK) && (sc->sc_scheduled & SCP_UPD_MASK) == 0) 2207 sc->sc_scheduled &= ~SCP_UPDATESUBCMD; 2208 2209 /* if nothing else needed cancel the timer */ 2210 if (sc->sc_scheduled == 0 && sc->sc_timoneed) { 2211 callout_stop(&sc->sc_check_scheduled_ch); 2212 sc->sc_timoneed = 0; 2213 } 2214 } 2215 2216 /* 2217 * called to indicate the 'cmdf' has been issued 2218 */ 2219 static void 2220 ray_cmd_ran(struct ray_softc *sc, int cmdf) 2221 { 2222 RAY_DPRINTF(("%s: ray_cmd_ran 0x%x\n", device_xname(sc->sc_dev), 2223 cmdf)); 2224 2225 if (cmdf & SCP_UPD_MASK) 2226 sc->sc_running |= cmdf | SCP_UPDATESUBCMD; 2227 else 2228 sc->sc_running |= cmdf; 2229 2230 if ((cmdf & SCP_TIMOCHECK_CMD_MASK) && !sc->sc_timocheck) { 2231 callout_reset(&sc->sc_check_ccs_ch, RAY_CHECK_CCS_TIMEOUT, 2232 ray_check_ccs, sc); 2233 sc->sc_timocheck = 1; 2234 } 2235 } 2236 2237 /* 2238 * check to see if `cmdf' has been issued 2239 */ 2240 static int 2241 ray_cmd_is_running(struct ray_softc *sc, int cmdf) 2242 { 2243 RAY_DPRINTF(("%s: ray_cmd_is_running 0x%x\n", device_xname(sc->sc_dev), 2244 cmdf)); 2245 2246 return ((sc->sc_running & cmdf) ? 1 : 0); 2247 } 2248 2249 /* 2250 * the given `cmdf' that was issued has completed 2251 */ 2252 static void 2253 ray_cmd_done(struct ray_softc *sc, int cmdf) 2254 { 2255 RAY_DPRINTF(("%s: ray_cmd_done 0x%x\n", device_xname(sc->sc_dev), 2256 cmdf)); 2257 2258 sc->sc_running &= ~cmdf; 2259 if (cmdf & SCP_UPD_MASK) { 2260 sc->sc_running &= ~SCP_UPDATESUBCMD; 2261 if (sc->sc_scheduled & SCP_UPD_MASK) 2262 ray_cmd_schedule(sc, sc->sc_scheduled & SCP_UPD_MASK); 2263 } 2264 if ((sc->sc_running & SCP_TIMOCHECK_CMD_MASK) == 0 && sc->sc_timocheck){ 2265 callout_stop(&sc->sc_check_ccs_ch); 2266 sc->sc_timocheck = 0; 2267 } 2268 } 2269 2270 /* 2271 * issue the command 2272 * only used for commands not tx 2273 */ 2274 static int 2275 ray_issue_cmd(struct ray_softc *sc, bus_size_t ccs, u_int track) 2276 { 2277 u_int i; 2278 2279 RAY_DPRINTF(("%s: ray_cmd_issue 0x%x\n", device_xname(sc->sc_dev), 2280 track)); 2281 2282 /* 2283 * XXX other drivers did this, but I think 2284 * what we really want to do is just make sure we don't 2285 * get here or that spinning is ok 2286 */ 2287 i = 0; 2288 while (!RAY_ECF_READY(sc)) 2289 if (++i > 50) { 2290 ray_free_ccs(sc, ccs); 2291 if (track) 2292 ray_cmd_schedule(sc, track); 2293 return (0); 2294 } 2295 2296 SRAM_WRITE_1(sc, RAY_SCB_CCSI, RAY_GET_INDEX(ccs)); 2297 RAY_ECF_START_CMD(sc); 2298 ray_cmd_ran(sc, track); 2299 2300 return (1); 2301 } 2302 2303 /* 2304 * send a simple command if we can 2305 */ 2306 static int 2307 ray_simple_cmd(struct ray_softc *sc, u_int cmd, u_int track) 2308 { 2309 bus_size_t ccs; 2310 2311 return (ray_alloc_ccs(sc, &ccs, cmd, track) && 2312 ray_issue_cmd(sc, ccs, track)); 2313 } 2314 2315 /* 2316 * Functions based on CCS commands 2317 */ 2318 2319 /* 2320 * run a update subcommand 2321 */ 2322 static void 2323 ray_update_subcmd(struct ray_softc *sc) 2324 { 2325 int submask, i; 2326 2327 RAY_DPRINTF(("%s: ray_update_subcmd\n", device_xname(sc->sc_dev))); 2328 2329 ray_cmd_cancel(sc, SCP_UPDATESUBCMD); 2330 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) 2331 return; 2332 submask = SCP_UPD_FIRST; 2333 for (i = 0; i < ray_nsubcmdtab; submask <<= 1, i++) { 2334 if ((sc->sc_scheduled & SCP_UPD_MASK) == 0) 2335 break; 2336 /* when done the next command will be scheduled */ 2337 if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) 2338 break; 2339 if (!RAY_ECF_READY(sc)) 2340 break; 2341 /* 2342 * give priority to LSB -- e.g., if previous loop rescheduled 2343 * doing this command after calling the function won't catch 2344 * if a later command sets an earlier bit 2345 */ 2346 if (sc->sc_scheduled & ((submask - 1) & SCP_UPD_MASK)) 2347 break; 2348 if (sc->sc_scheduled & submask) 2349 (*ray_subcmdtab[i])(sc); 2350 } 2351 } 2352 2353 /* 2354 * report a parameter 2355 */ 2356 static void 2357 ray_report_params(struct ray_softc *sc) 2358 { 2359 bus_size_t ccs; 2360 2361 ray_cmd_cancel(sc, SCP_REPORTPARAMS); 2362 2363 if (!sc->sc_repreq) 2364 return; 2365 2366 /* do the issue check before equality check */ 2367 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) 2368 return; 2369 else if (ray_cmd_is_running(sc, SCP_REPORTPARAMS)) { 2370 ray_cmd_schedule(sc, SCP_REPORTPARAMS); 2371 return; 2372 } else if (!ray_alloc_ccs(sc, &ccs, RAY_CMD_REPORT_PARAMS, 2373 SCP_REPORTPARAMS)) 2374 return; 2375 2376 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_report, c_paramid, 2377 sc->sc_repreq->r_paramid); 2378 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_report, c_nparam, 1); 2379 (void)ray_issue_cmd(sc, ccs, SCP_REPORTPARAMS); 2380 } 2381 2382 /* 2383 * start an association 2384 */ 2385 static void 2386 ray_start_assoc(struct ray_softc *sc) 2387 { 2388 ray_cmd_cancel(sc, SCP_STARTASSOC); 2389 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) 2390 return; 2391 else if (ray_cmd_is_running(sc, SCP_STARTASSOC)) 2392 return; 2393 (void)ray_simple_cmd(sc, RAY_CMD_START_ASSOC, SCP_STARTASSOC); 2394 } 2395 2396 /* 2397 * Subcommand functions that use the SCP_UPDATESUBCMD command 2398 * (and are serialized with respect to other update sub commands 2399 */ 2400 2401 /* 2402 * download the startup parameters to the card 2403 * -- no outstanding commands expected 2404 */ 2405 static void 2406 ray_download_params(struct ray_softc *sc) 2407 { 2408 struct ray_startup_params_head *sp; 2409 struct ray_startup_params_tail_5 *sp5; 2410 struct ray_startup_params_tail_4 *sp4; 2411 bus_size_t off; 2412 2413 RAY_DPRINTF(("%s: init_startup_params\n", device_xname(sc->sc_dev))); 2414 2415 ray_cmd_cancel(sc, SCP_UPD_STARTUP); 2416 2417 #define PUT2(p, v) \ 2418 do { (p)[0] = ((v >> 8) & 0xff); (p)[1] = (v & 0xff); } while(0) 2419 2420 sp = &sc->sc_startup; 2421 sp4 = &sc->sc_startup_4; 2422 sp5 = &sc->sc_startup_5; 2423 memset(sp, 0, sizeof(*sp)); 2424 if (sc->sc_version == SC_BUILD_4) 2425 memset(sp4, 0, sizeof(*sp4)); 2426 else 2427 memset(sp5, 0, sizeof(*sp5)); 2428 /* XXX: Raylink firmware doesn't have length field for ssid */ 2429 memcpy(sp->sp_ssid, sc->sc_dnwid.i_nwid, sizeof(sp->sp_ssid)); 2430 sp->sp_scan_mode = 0x1; 2431 memcpy(sp->sp_mac_addr, sc->sc_ecf_startup.e_station_addr, 2432 ETHER_ADDR_LEN); 2433 PUT2(sp->sp_frag_thresh, 0x7fff); /* disabled */ 2434 if (sc->sc_version == SC_BUILD_4) { 2435 #if 1 2436 /* linux/fbsd */ 2437 PUT2(sp->sp_dwell_time, 0x200); 2438 PUT2(sp->sp_beacon_period, 1); 2439 #else 2440 /* divined */ 2441 PUT2(sp->sp_dwell_time, 0x400); 2442 PUT2(sp->sp_beacon_period, 0); 2443 #endif 2444 } else { 2445 PUT2(sp->sp_dwell_time, 128); 2446 PUT2(sp->sp_beacon_period, 256); 2447 } 2448 sp->sp_dtim_interval = 1; 2449 #if 0 2450 /* these are the documented defaults for build 5/6 */ 2451 sp->sp_max_retry = 0x1f; 2452 sp->sp_ack_timo = 0x86; 2453 sp->sp_sifs = 0x1c; 2454 #elif 1 2455 /* these were scrounged from the linux driver */ 2456 sp->sp_max_retry = 0x07; 2457 2458 sp->sp_ack_timo = 0xa3; 2459 sp->sp_sifs = 0x1d; 2460 #else 2461 /* these were divined */ 2462 sp->sp_max_retry = 0x03; 2463 2464 sp->sp_ack_timo = 0xa3; 2465 sp->sp_sifs = 0x1d; 2466 #endif 2467 #if 0 2468 /* these are the documented defaults for build 5/6 */ 2469 sp->sp_difs = 0x82; 2470 sp->sp_pifs = 0; 2471 #else 2472 /* linux/fbsd */ 2473 sp->sp_difs = 0x82; 2474 2475 if (sc->sc_version == SC_BUILD_4) 2476 sp->sp_pifs = 0xce; 2477 else 2478 sp->sp_pifs = 0x4e; 2479 #endif 2480 2481 PUT2(sp->sp_rts_thresh, 0x7fff); /* disabled */ 2482 if (sc->sc_version == SC_BUILD_4) { 2483 PUT2(sp->sp_scan_dwell, 0xfb1e); 2484 PUT2(sp->sp_scan_max_dwell, 0xc75c); 2485 } else { 2486 PUT2(sp->sp_scan_dwell, 0x4e2); 2487 PUT2(sp->sp_scan_max_dwell, 0x38a4); 2488 } 2489 sp->sp_assoc_timo = 0x5; 2490 if (sc->sc_version == SC_BUILD_4) { 2491 #if 0 2492 /* linux/fbsd */ 2493 sp->sp_adhoc_scan_cycle = 0x4; 2494 sp->sp_infra_scan_cycle = 0x2; 2495 sp->sp_infra_super_scan_cycle = 0x4; 2496 #else 2497 /* divined */ 2498 sp->sp_adhoc_scan_cycle = 0x8; 2499 sp->sp_infra_scan_cycle = 0x1; 2500 sp->sp_infra_super_scan_cycle = 0x18; 2501 #endif 2502 } else { 2503 sp->sp_adhoc_scan_cycle = 0x8; 2504 sp->sp_infra_scan_cycle = 0x2; 2505 sp->sp_infra_super_scan_cycle = 0x8; 2506 } 2507 sp->sp_promisc = sc->sc_promisc; 2508 PUT2(sp->sp_uniq_word, 0x0cbd); 2509 if (sc->sc_version == SC_BUILD_4) { 2510 /* XXX what is this value anyway..? the std says 50us */ 2511 /* XXX sp->sp_slot_time = 0x4e; */ 2512 sp->sp_slot_time = 0x4e; 2513 #if 1 2514 /*linux/fbsd*/ 2515 sp->sp_roam_low_snr_thresh = 0xff; 2516 #else 2517 /*divined*/ 2518 sp->sp_roam_low_snr_thresh = 0x30; 2519 #endif 2520 } else { 2521 sp->sp_slot_time = 0x32; 2522 sp->sp_roam_low_snr_thresh = 0xff; /* disabled */ 2523 } 2524 #if 1 2525 sp->sp_low_snr_count = 0xff; /* disabled */ 2526 #else 2527 /* divined -- check */ 2528 sp->sp_low_snr_count = 0x07; /* disabled */ 2529 #endif 2530 #if 0 2531 sp->sp_infra_missed_beacon_count = 0x2; 2532 #elif 1 2533 /* linux/fbsd */ 2534 sp->sp_infra_missed_beacon_count = 0x5; 2535 #else 2536 /* divined -- check, looks fishy */ 2537 sp->sp_infra_missed_beacon_count = 0x7; 2538 #endif 2539 sp->sp_adhoc_missed_beacon_count = 0xff; 2540 sp->sp_country_code = sc->sc_dcountrycode; 2541 sp->sp_hop_seq = 0x0b; 2542 if (sc->sc_version == SC_BUILD_4) { 2543 sp->sp_hop_seq_len = 0x4e; 2544 sp4->sp_cw_max = 0x3f; /* single byte on build 4 */ 2545 sp4->sp_cw_min = 0x0f; /* single byte on build 4 */ 2546 sp4->sp_noise_filter_gain = 0x4; 2547 sp4->sp_noise_limit_offset = 0x8; 2548 sp4->sp_rssi_thresh_offset = 0x28; 2549 sp4->sp_busy_thresh_offset = 0x28; 2550 sp4->sp_sync_thresh = 0x07; 2551 sp4->sp_test_mode = 0x0; 2552 sp4->sp_test_min_chan = 0x2; 2553 sp4->sp_test_max_chan = 0x2; 2554 } else { 2555 sp->sp_hop_seq_len = 0x4f; 2556 PUT2(sp5->sp_cw_max, 0x3f); 2557 PUT2(sp5->sp_cw_min, 0x0f); 2558 sp5->sp_noise_filter_gain = 0x4; 2559 sp5->sp_noise_limit_offset = 0x8; 2560 sp5->sp_rssi_thresh_offset = 0x28; 2561 sp5->sp_busy_thresh_offset = 0x28; 2562 sp5->sp_sync_thresh = 0x07; 2563 sp5->sp_test_mode = 0x0; 2564 sp5->sp_test_min_chan = 0x2; 2565 sp5->sp_test_max_chan = 0x2; 2566 #if 0 2567 sp5->sp_allow_probe_resp = 0x1; 2568 #else 2569 sp5->sp_allow_probe_resp = 0x0; 2570 #endif 2571 sp5->sp_privacy_must_start = 0x0; 2572 sp5->sp_privacy_can_join = 0x0; 2573 sp5->sp_basic_rate_set[0] = 0x2; 2574 /* 2 = 1Mbps, 3 = old 2Mbps 4 = 2Mbps */ 2575 } 2576 2577 /* we shouldn't be called with some command pending */ 2578 if (!RAY_ECF_READY(sc)) 2579 panic("ray_download_params busy"); 2580 2581 /* write the compatible part */ 2582 off = RAY_HOST_TO_ECF_BASE; 2583 ray_write_region(sc, off, sp, sizeof(sc->sc_startup)); 2584 off += sizeof(sc->sc_startup); 2585 if (sc->sc_version == SC_BUILD_4) 2586 ray_write_region(sc, off, sp4, sizeof(*sp4)); 2587 else 2588 ray_write_region(sc, off, sp5, sizeof(*sp5)); 2589 if (!ray_simple_cmd(sc, RAY_CMD_START_PARAMS, SCP_UPD_STARTUP)) 2590 panic("ray_download_params issue"); 2591 } 2592 2593 /* 2594 * start or join a network 2595 */ 2596 static void 2597 ray_start_join_net(struct ray_softc *sc) 2598 { 2599 struct ray_net_params np; 2600 bus_size_t ccs; 2601 int cmd; 2602 2603 ray_cmd_cancel(sc, SCP_UPD_STARTJOIN); 2604 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) 2605 return; 2606 2607 /* XXX check we may not want to re-issue */ 2608 if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) { 2609 ray_cmd_schedule(sc, SCP_UPD_STARTJOIN); 2610 return; 2611 } 2612 2613 if (sc->sc_mode == SC_MODE_ADHOC) 2614 cmd = RAY_CMD_START_NET; 2615 else 2616 cmd = RAY_CMD_JOIN_NET; 2617 2618 if (!ray_alloc_ccs(sc, &ccs, cmd, SCP_UPD_STARTJOIN)) 2619 return; 2620 sc->sc_startccs = ccs; 2621 sc->sc_startcmd = cmd; 2622 if (!memcmp(&sc->sc_cnwid, &sc->sc_dnwid, sizeof(sc->sc_cnwid)) 2623 && sc->sc_omode == sc->sc_mode) 2624 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_upd_param, 0); 2625 else { 2626 sc->sc_havenet = 0; 2627 memset(&np, 0, sizeof(np)); 2628 np.p_net_type = sc->sc_mode; 2629 memcpy(np.p_ssid, sc->sc_dnwid.i_nwid, sizeof(np.p_ssid)); 2630 ray_write_region(sc, RAY_HOST_TO_ECF_BASE, &np, sizeof(np)); 2631 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_upd_param, 1); 2632 } 2633 if (ray_issue_cmd(sc, ccs, SCP_UPD_STARTJOIN)) 2634 callout_reset(&sc->sc_start_join_timo_ch, RAY_START_TIMEOUT, 2635 ray_start_join_timo, sc); 2636 } 2637 2638 static void 2639 ray_start_join_timo(void *arg) 2640 { 2641 struct ray_softc *sc; 2642 u_int stat; 2643 2644 sc = arg; 2645 stat = SRAM_READ_FIELD_1(sc, sc->sc_startccs, ray_cmd, c_status); 2646 ray_start_join_net_done(sc, sc->sc_startcmd, sc->sc_startccs, stat); 2647 } 2648 2649 /* 2650 * The start/join has completed. Note: we timeout the start 2651 * command because it seems to fail to work at least on the 2652 * build 4 firmware without reporting an error. This actually 2653 * may be a result of not putting the correct params in the 2654 * initial download. If this is a timeout `stat' will be 2655 * marked busy. 2656 */ 2657 static ray_cmd_func_t 2658 ray_start_join_net_done(struct ray_softc *sc, u_int cmd, bus_size_t ccs, 2659 u_int stat) 2660 { 2661 int i; 2662 struct ray_net_params np; 2663 2664 callout_stop(&sc->sc_start_join_timo_ch); 2665 ray_cmd_done(sc, SCP_UPD_STARTJOIN); 2666 2667 if (stat == RAY_CCS_STATUS_FAIL) { 2668 /* XXX poke ifmedia when it supports this */ 2669 sc->sc_havenet = 0; 2670 return (ray_start_join_net); 2671 } 2672 if (stat == RAY_CCS_STATUS_BUSY || stat == RAY_CCS_STATUS_FREE) { 2673 /* handle the timeout condition */ 2674 callout_reset(&sc->sc_start_join_timo_ch, RAY_START_TIMEOUT, 2675 ray_start_join_timo, sc); 2676 2677 /* be safe -- not a lot occurs with no net though */ 2678 if (!RAY_ECF_READY(sc)) 2679 return (0); 2680 2681 /* see if our nwid is up to date */ 2682 if (!memcmp(&sc->sc_cnwid, &sc->sc_dnwid, sizeof(sc->sc_cnwid)) 2683 && sc->sc_omode == sc->sc_mode) 2684 SRAM_WRITE_FIELD_1(sc,ccs, ray_cmd_net, c_upd_param, 0); 2685 else { 2686 memset(&np, 0, sizeof(np)); 2687 np.p_net_type = sc->sc_mode; 2688 memcpy(np.p_ssid, sc->sc_dnwid.i_nwid, 2689 sizeof(np.p_ssid)); 2690 ray_write_region(sc, RAY_HOST_TO_ECF_BASE, &np, 2691 sizeof(np)); 2692 SRAM_WRITE_FIELD_1(sc,ccs, ray_cmd_net, c_upd_param, 1); 2693 } 2694 2695 if (sc->sc_mode == SC_MODE_ADHOC) 2696 cmd = RAY_CMD_START_NET; 2697 else 2698 cmd = RAY_CMD_JOIN_NET; 2699 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_cmd, 2700 RAY_CCS_STATUS_BUSY); 2701 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_status, 2702 RAY_CCS_STATUS_BUSY); 2703 2704 /* we simply poke the card again issuing the same ccs */ 2705 SRAM_WRITE_1(sc, RAY_SCB_CCSI, RAY_GET_INDEX(ccs)); 2706 RAY_ECF_START_CMD(sc); 2707 ray_cmd_ran(sc, SCP_UPD_STARTJOIN); 2708 return (0); 2709 } 2710 /* get the current ssid */ 2711 SRAM_READ_FIELD_N(sc, ccs, ray_cmd_net, c_bss_id, sc->sc_bssid, 2712 sizeof(sc->sc_bssid)); 2713 2714 sc->sc_deftxrate = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_net,c_def_txrate); 2715 sc->sc_encrypt = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_net, c_encrypt); 2716 2717 /* adjust values for buggy build 4 */ 2718 if (sc->sc_deftxrate == 0x55) 2719 sc->sc_deftxrate = RAY_PID_BASIC_RATE_1500K; 2720 if (sc->sc_encrypt == 0x55) 2721 sc->sc_encrypt = 0; 2722 2723 if (SRAM_READ_FIELD_1(sc, ccs, ray_cmd_net, c_upd_param)) { 2724 ray_read_region(sc, RAY_HOST_TO_ECF_BASE, &np, sizeof(np)); 2725 /* XXX: Raylink firmware doesn't have length field for ssid */ 2726 for (i = 0; i < sizeof(np.p_ssid); i++) { 2727 if (np.p_ssid[i] == '\0') 2728 break; 2729 } 2730 sc->sc_cnwid.i_len = i; 2731 memcpy(sc->sc_cnwid.i_nwid, np.p_ssid, i); 2732 sc->sc_omode = sc->sc_mode; 2733 if (np.p_net_type != sc->sc_mode) 2734 return (ray_start_join_net); 2735 } 2736 RAY_DPRINTF(("%s: net start/join nwid %.32s bssid %s inited %d\n", 2737 device_xname(sc->sc_dev), sc->sc_cnwid.i_nwid, 2738 ether_sprintf(sc->sc_bssid), 2739 SRAM_READ_FIELD_1(sc, ccs, ray_cmd_net, c_inited))); 2740 2741 /* network is now active */ 2742 ray_cmd_schedule(sc, SCP_UPD_MCAST|SCP_UPD_PROMISC); 2743 if (cmd == RAY_CMD_JOIN_NET) 2744 return (ray_start_assoc); 2745 else { 2746 sc->sc_havenet = 1; 2747 return (ray_intr_start); 2748 } 2749 } 2750 2751 /* 2752 * set the card in/out of promiscuous mode 2753 */ 2754 static void 2755 ray_update_promisc(struct ray_softc *sc) 2756 { 2757 bus_size_t ccs; 2758 int promisc; 2759 2760 ray_cmd_cancel(sc, SCP_UPD_PROMISC); 2761 2762 /* do the issue check before equality check */ 2763 if (sc->sc_if.if_flags & IFF_ALLMULTI) 2764 sc->sc_if.if_flags |= IFF_PROMISC; 2765 else if (sc->sc_if.if_pcount == 0) 2766 sc->sc_if.if_flags &= ~IFF_PROMISC; 2767 promisc = !!(sc->sc_if.if_flags & IFF_PROMISC); 2768 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) 2769 return; 2770 else if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) { 2771 ray_cmd_schedule(sc, SCP_UPD_PROMISC); 2772 return; 2773 } else if (promisc == sc->sc_promisc) 2774 return; 2775 else if (!ray_alloc_ccs(sc,&ccs,RAY_CMD_UPDATE_PARAMS, SCP_UPD_PROMISC)) 2776 return; 2777 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update, c_paramid, RAY_PID_PROMISC); 2778 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update, c_nparam, 1); 2779 SRAM_WRITE_1(sc, RAY_HOST_TO_ECF_BASE, promisc); 2780 (void)ray_issue_cmd(sc, ccs, SCP_UPD_PROMISC); 2781 } 2782 2783 /* 2784 * update the parameter based on what the user passed in 2785 */ 2786 static void 2787 ray_update_params(struct ray_softc *sc) 2788 { 2789 bus_size_t ccs; 2790 2791 ray_cmd_cancel(sc, SCP_UPD_UPDATEPARAMS); 2792 if (!sc->sc_updreq) { 2793 /* XXX do we need to wakeup here? */ 2794 return; 2795 } 2796 2797 /* do the issue check before equality check */ 2798 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) 2799 return; 2800 else if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) { 2801 ray_cmd_schedule(sc, SCP_UPD_UPDATEPARAMS); 2802 return; 2803 } else if (!ray_alloc_ccs(sc, &ccs, RAY_CMD_UPDATE_PARAMS, 2804 SCP_UPD_UPDATEPARAMS)) 2805 return; 2806 2807 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update, c_paramid, 2808 sc->sc_updreq->r_paramid); 2809 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update, c_nparam, 1); 2810 ray_write_region(sc, RAY_HOST_TO_ECF_BASE, sc->sc_updreq->r_data, 2811 sc->sc_updreq->r_len); 2812 2813 (void)ray_issue_cmd(sc, ccs, SCP_UPD_UPDATEPARAMS); 2814 } 2815 2816 /* 2817 * set the multicast filter list 2818 */ 2819 static void 2820 ray_update_mcast(struct ray_softc *sc) 2821 { 2822 bus_size_t ccs; 2823 struct ether_multistep step; 2824 struct ether_multi *enm; 2825 struct ethercom *ec; 2826 bus_size_t bufp; 2827 int count; 2828 2829 ec = &sc->sc_ec; 2830 ray_cmd_cancel(sc, SCP_UPD_MCAST); 2831 2832 /* see if we have any ranges */ 2833 if ((count = sc->sc_ec.ec_multicnt) < 17) { 2834 ETHER_FIRST_MULTI(step, ec, enm); 2835 while (enm) { 2836 /* see if this is a range */ 2837 if (memcmp(enm->enm_addrlo, enm->enm_addrhi, 2838 ETHER_ADDR_LEN)) { 2839 count = 17; 2840 break; 2841 } 2842 ETHER_NEXT_MULTI(step, enm); 2843 } 2844 } 2845 2846 /* track this stuff even when not running */ 2847 if (count > 16) { 2848 sc->sc_if.if_flags |= IFF_ALLMULTI; 2849 ray_update_promisc(sc); 2850 return; 2851 } else if (sc->sc_if.if_flags & IFF_ALLMULTI) { 2852 sc->sc_if.if_flags &= ~IFF_ALLMULTI; 2853 ray_update_promisc(sc); 2854 } 2855 2856 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) 2857 return; 2858 else if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) { 2859 ray_cmd_schedule(sc, SCP_UPD_MCAST); 2860 return; 2861 } else if (!ray_alloc_ccs(sc,&ccs, RAY_CMD_UPDATE_MCAST, SCP_UPD_MCAST)) 2862 return; 2863 SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update_mcast, c_nmcast, count); 2864 bufp = RAY_HOST_TO_ECF_BASE; 2865 ETHER_FIRST_MULTI(step, ec, enm); 2866 while (enm) { 2867 ray_write_region(sc, bufp, enm->enm_addrlo, ETHER_ADDR_LEN); 2868 bufp += ETHER_ADDR_LEN; 2869 ETHER_NEXT_MULTI(step, enm); 2870 } 2871 (void)ray_issue_cmd(sc, ccs, SCP_UPD_MCAST); 2872 } 2873 2874 /* 2875 * User issued commands 2876 */ 2877 2878 /* 2879 * issue an "update params" 2880 * 2881 * expected to be called in sleepable context -- intended for user stuff 2882 */ 2883 static int 2884 ray_user_update_params(struct ray_softc *sc, struct ray_param_req *pr) 2885 { 2886 int rv; 2887 2888 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) { 2889 pr->r_failcause = RAY_FAILCAUSE_EDEVSTOP; 2890 return (EIO); 2891 } 2892 2893 /* wait to be able to issue the command */ 2894 rv = 0; 2895 while (ray_cmd_is_running(sc, SCP_UPD_UPDATEPARAMS) || 2896 ray_cmd_is_scheduled(sc, SCP_UPD_UPDATEPARAMS)) { 2897 rv = tsleep(ray_update_params, 0|PCATCH, "cmd in use", 0); 2898 if (rv) 2899 return (rv); 2900 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) { 2901 pr->r_failcause = RAY_FAILCAUSE_EDEVSTOP; 2902 return (EIO); 2903 } 2904 } 2905 2906 pr->r_failcause = RAY_FAILCAUSE_WAITING; 2907 sc->sc_updreq = pr; 2908 ray_cmd_schedule(sc, SCP_UPD_UPDATEPARAMS); 2909 ray_check_scheduled(sc); 2910 2911 while (pr->r_failcause == RAY_FAILCAUSE_WAITING) 2912 (void)tsleep(ray_update_params, 0, "waiting cmd", 0); 2913 wakeup(ray_update_params); 2914 2915 return (0); 2916 } 2917 2918 /* 2919 * issue a report params 2920 * 2921 * expected to be called in sleepable context -- intended for user stuff 2922 */ 2923 static int 2924 ray_user_report_params(struct ray_softc *sc, struct ray_param_req *pr) 2925 { 2926 int rv; 2927 2928 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) { 2929 pr->r_failcause = RAY_FAILCAUSE_EDEVSTOP; 2930 return (EIO); 2931 } 2932 2933 /* wait to be able to issue the command */ 2934 rv = 0; 2935 while (ray_cmd_is_running(sc, SCP_REPORTPARAMS) 2936 || ray_cmd_is_scheduled(sc, SCP_REPORTPARAMS)) { 2937 rv = tsleep(ray_report_params, 0|PCATCH, "cmd in use", 0); 2938 if (rv) 2939 return (rv); 2940 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) { 2941 pr->r_failcause = RAY_FAILCAUSE_EDEVSTOP; 2942 return (EIO); 2943 } 2944 } 2945 2946 pr->r_failcause = RAY_FAILCAUSE_WAITING; 2947 sc->sc_repreq = pr; 2948 ray_cmd_schedule(sc, SCP_REPORTPARAMS); 2949 ray_check_scheduled(sc); 2950 2951 while (pr->r_failcause == RAY_FAILCAUSE_WAITING) 2952 (void)tsleep(ray_report_params, 0, "waiting cmd", 0); 2953 wakeup(ray_report_params); 2954 2955 return (0); 2956 } 2957 2958 2959 /* 2960 * this is a temporary wrapper around bus_space_read_region_1 2961 * as it seems to mess with gcc. the line numbers get offset 2962 * presumably this is related to the inline asm on i386. 2963 */ 2964 2965 static void 2966 ray_read_region(struct ray_softc *sc, bus_size_t off, void *vp, size_t c) 2967 { 2968 #ifdef RAY_USE_OPTIMIZED_COPY 2969 u_int n2, n4, tmp; 2970 u_int8_t *p; 2971 2972 p = vp; 2973 2974 /* XXX we may be making poor assumptions here but lets hope */ 2975 switch ((off|(bus_addr_t)p) & 0x03) { 2976 case 0: 2977 if ((n4 = c / 4)) { 2978 bus_space_read_region_4(sc->sc_memt, sc->sc_memh, off, 2979 p, n4); 2980 tmp = c & ~0x3; 2981 c &= 0x3; 2982 p += tmp; 2983 off += tmp; 2984 } 2985 switch (c) { 2986 case 3: 2987 *p = bus_space_read_1(sc->sc_memt,sc->sc_memh, off); 2988 p++, off++; 2989 case 2: 2990 *p = bus_space_read_1(sc->sc_memt,sc->sc_memh, off); 2991 p++, off++; 2992 case 1: 2993 *p = bus_space_read_1(sc->sc_memt,sc->sc_memh, off); 2994 } 2995 break; 2996 case 2: 2997 if ((n2 = (c >> 1))) 2998 bus_space_read_region_2(sc->sc_memt, sc->sc_memh, off, 2999 p, n2); 3000 if (c & 1) { 3001 c &= ~0x1; 3002 *(p + c) = bus_space_read_1(sc->sc_memt, sc->sc_memh, 3003 off + c); 3004 } 3005 break; 3006 case 1: 3007 case 3: 3008 bus_space_read_region_1(sc->sc_memt, sc->sc_memh, off, p, c); 3009 break; 3010 } 3011 #else 3012 bus_space_read_region_1(sc->sc_memt, sc->sc_memh, off, vp, c); 3013 #endif 3014 } 3015 3016 /* 3017 * this is a temporary wrapper around bus_space_write_region_1 3018 * as it seems to mess with gcc. the line numbers get offset 3019 * presumably this is related to the inline asm on i386. 3020 */ 3021 static void 3022 ray_write_region(struct ray_softc *sc, bus_size_t off, void *vp, size_t c) 3023 { 3024 #ifdef RAY_USE_OPTIMIZED_COPY 3025 size_t n2, n4, tmp; 3026 u_int8_t *p; 3027 3028 p = vp; 3029 /* XXX we may be making poor assumptions here but lets hope */ 3030 switch ((off|(bus_addr_t)p) & 0x03) { 3031 case 0: 3032 if ((n4 = (c >> 2))) { 3033 bus_space_write_region_4(sc->sc_memt, sc->sc_memh, off, 3034 p, n4); 3035 tmp = c & ~0x3; 3036 c &= 0x3; 3037 p += tmp; 3038 off += tmp; 3039 } 3040 switch (c) { 3041 case 3: 3042 bus_space_write_1(sc->sc_memt,sc->sc_memh, off, *p); 3043 p++, off++; 3044 case 2: 3045 bus_space_write_1(sc->sc_memt,sc->sc_memh, off, *p); 3046 p++, off++; 3047 case 1: 3048 bus_space_write_1(sc->sc_memt,sc->sc_memh, off, *p); 3049 } 3050 break; 3051 case 2: 3052 if ((n2 = (c >> 1))) 3053 bus_space_write_region_2(sc->sc_memt, sc->sc_memh, off, 3054 p, n2); 3055 if (c & 0x1) { 3056 c &= ~0x1; 3057 bus_space_write_1(sc->sc_memt, sc->sc_memh, 3058 off + c, *(p + c)); 3059 } 3060 break; 3061 case 1: 3062 case 3: 3063 bus_space_write_region_1(sc->sc_memt, sc->sc_memh, off, p, c); 3064 break; 3065 } 3066 #else 3067 bus_space_write_region_1(sc->sc_memt, sc->sc_memh, off, vp, c); 3068 #endif 3069 } 3070 3071 #ifdef RAY_DEBUG 3072 3073 #define PRINTABLE(c) ((c) >= 0x20 && (c) <= 0x7f) 3074 3075 void 3076 hexdump(const u_int8_t *d, int len, int br, int div, int fl) 3077 { 3078 int i, j, offw, first, tlen, ni, nj, sp; 3079 3080 sp = br / div; 3081 offw = 0; 3082 if (len && (fl & HEXDF_NOOFFSET) == 0) { 3083 tlen = len; 3084 do { 3085 offw++; 3086 } while (tlen /= br); 3087 } 3088 if (offw) 3089 printf("%0*x: ", offw, 0); 3090 for (i = 0; i < len; i++, d++) { 3091 if (i && (i % br) == 0) { 3092 if ((fl & HEXDF_NOASCII) == 0) { 3093 printf(" "); 3094 d -= br; 3095 for (j = 0; j < br; d++, j++) { 3096 if (j && (j % sp) == 0) 3097 printf(" "); 3098 if (PRINTABLE(*d)) 3099 printf("%c", (int)*d); 3100 else 3101 printf("."); 3102 } 3103 } 3104 if (offw) 3105 printf("\n%0*x: ", offw, i); 3106 else 3107 printf("\n"); 3108 if ((fl & HEXDF_NOCOMPRESS) == 0) { 3109 first = 1; 3110 while (len - i >= br) { 3111 if (memcmp(d, d - br, br)) 3112 break; 3113 d += br; 3114 i += br; 3115 if (first) { 3116 printf("*"); 3117 first = 0; 3118 } 3119 } 3120 if (len == i) { 3121 printf("\n%0*x", offw, i); 3122 return; 3123 } 3124 } 3125 } else if (i && (i % sp) == 0) 3126 printf(" "); 3127 printf("%02x ", *d); 3128 } 3129 if (len && (((i - 1) % br) || i == 1)) { 3130 if ((fl & HEXDF_NOASCII) == 0) { 3131 i = i % br ? i % br : br; 3132 ni = (br - i) % br; 3133 j = (i - 1) / sp; 3134 nj = (div - j - 1) % div; 3135 j = 3 * ni + nj + 3; 3136 printf("%*s", j, ""); 3137 d -= i; 3138 for (j = 0; j < i; d++, j++) { 3139 if (j && (j % sp) == 0) 3140 printf(" "); 3141 if (PRINTABLE(*d)) 3142 printf("%c", (int)*d); 3143 else 3144 printf("."); 3145 } 3146 } 3147 printf("\n"); 3148 } 3149 } 3150 3151 3152 3153 static void 3154 ray_dump_mbuf(struct ray_softc *sc, struct mbuf *m) 3155 { 3156 u_int8_t *d, *ed; 3157 u_int i; 3158 3159 printf("%s: pkt dump:", device_xname(sc->sc_dev)); 3160 i = 0; 3161 for (; m; m = m->m_next) { 3162 d = mtod(m, u_int8_t *); 3163 ed = d + m->m_len; 3164 3165 for (; d < ed; i++, d++) { 3166 if ((i % 16) == 0) 3167 printf("\n\t"); 3168 else if ((i % 8) == 0) 3169 printf(" "); 3170 printf(" %02x", *d); 3171 } 3172 } 3173 if ((i - 1) % 16) 3174 printf("\n"); 3175 } 3176 #endif /* RAY_DEBUG */ 3177 3178 #ifdef RAY_DO_SIGLEV 3179 static void 3180 ray_update_siglev(struct ray_softc *sc, u_int8_t *src, u_int8_t siglev) 3181 { 3182 int i, mini; 3183 struct timeval mint; 3184 struct ray_siglev *sl; 3185 3186 /* try to find host */ 3187 for (i = 0; i < RAY_NSIGLEVRECS; i++) { 3188 sl = &sc->sc_siglevs[i]; 3189 if (memcmp(sl->rsl_host, src, ETHER_ADDR_LEN) == 0) 3190 goto found; 3191 } 3192 /* not found, find oldest slot */ 3193 mini = 0; 3194 mint.tv_sec = LONG_MAX; 3195 mint.tv_usec = 0; 3196 for (i = 0; i < RAY_NSIGLEVRECS; i++) { 3197 sl = &sc->sc_siglevs[i]; 3198 if (timercmp(&sl->rsl_time, &mint, <)) { 3199 mini = i; 3200 mint = sl->rsl_time; 3201 } 3202 } 3203 sl = &sc->sc_siglevs[mini]; 3204 memset(sl->rsl_siglevs, 0, RAY_NSIGLEV); 3205 memcpy(sl->rsl_host, src, ETHER_ADDR_LEN); 3206 3207 found: 3208 microtime(&sl->rsl_time); 3209 memmove(&sl->rsl_siglevs[1], sl->rsl_siglevs, RAY_NSIGLEV-1); 3210 sl->rsl_siglevs[0] = siglev; 3211 } 3212 #endif 3213