1 /* $NetBSD: if_cnw.c,v 1.68 2020/01/29 13:54:41 thorpej Exp $ */ 2 3 /*- 4 * Copyright (c) 1998, 2004 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Michael Eriksson. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * Copyright (c) 1996, 1997 Berkeley Software Design, Inc. 34 * All rights reserved. 35 * 36 * Redistribution and use in source and binary forms, with or without 37 * modification, are permitted provided that this notice is retained, 38 * the conditions in the following notices are met, and terms applying 39 * to contributors in the following notices also apply to Berkeley 40 * Software Design, Inc. 41 * 42 * 1. Redistributions of source code must retain the above copyright 43 * notice, this list of conditions and the following disclaimer. 44 * 2. Redistributions in binary form must reproduce the above copyright 45 * notice, this list of conditions and the following disclaimer in the 46 * documentation and/or other materials provided with the distribution. 47 * 3. All advertising materials mentioning features or use of this software 48 * must display the following acknowledgement: 49 * This product includes software developed by 50 * Berkeley Software Design, Inc. 51 * 4. Neither the name of the Berkeley Software Design, Inc. nor the names 52 * of its contributors may be used to endorse or promote products derived 53 * from this software without specific prior written permission. 54 * 55 * THIS SOFTWARE IS PROVIDED BY BERKELEY SOFTWARE DESIGN, INC. ``AS IS'' AND 56 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 57 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 58 * ARE DISCLAIMED. IN NO EVENT SHALL BERKELEY SOFTWARE DESIGN, INC. BE LIABLE 59 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 60 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 61 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 62 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 63 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 64 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 65 * SUCH DAMAGE. 66 * 67 * Paul Borman, December 1996 68 * 69 * This driver is derived from a generic frame work which is 70 * Copyright(c) 1994,1995,1996 71 * Yoichi Shinoda, Yoshitaka Tokugawa, WIDE Project, Wildboar Project 72 * and Foretune. All rights reserved. 73 * 74 * A linux driver was used as the "hardware reference manual" (i.e., 75 * to determine registers and a general outline of how the card works) 76 * That driver is publically available and copyright 77 * 78 * John Markus Bjrndalen 79 * Department of Computer Science 80 * University of Troms 81 * Norway 82 * johnm (at) staff.cs.uit.no, http://www.cs.uit.no/~johnm/ 83 */ 84 85 /* 86 * This is a driver for the Xircom CreditCard Netwave (also known as 87 * the Netwave Airsurfer) wireless LAN PCMCIA adapter. 88 * 89 * When this driver was developed, the Linux Netwave driver was used 90 * as a hardware manual. That driver is Copyright (c) 1997 University 91 * of Troms, Norway. It is part of the Linux pcmcia-cs package that 92 * can be found at http://pcmcia-cs.sourceforge.net/. The most recent 93 * version of the pcmcia-cs package when this driver was written was 94 * 3.0.6. 95 * 96 * Unfortunately, a lot of explicit numeric constants were used in the 97 * Linux driver. I have tried to use symbolic names whenever possible, 98 * but since I don't have any real hardware documentation, there's 99 * still one or two "magic numbers" :-(. 100 * 101 * Driver limitations: This driver doesn't do multicasting or receiver 102 * promiscuity, because of missing hardware documentation. I couldn't 103 * get receiver promiscuity to work, and I haven't even tried 104 * multicast. Volunteers are welcome, of course :-). 105 */ 106 107 #include <sys/cdefs.h> 108 __KERNEL_RCSID(0, "$NetBSD: if_cnw.c,v 1.68 2020/01/29 13:54:41 thorpej Exp $"); 109 110 #include "opt_inet.h" 111 112 #include <sys/param.h> 113 #include <sys/systm.h> 114 #include <sys/device.h> 115 #include <sys/socket.h> 116 #include <sys/mbuf.h> 117 #include <sys/ioctl.h> 118 #include <sys/proc.h> 119 #include <sys/kauth.h> 120 121 #include <net/if.h> 122 123 #include <dev/pcmcia/if_cnwreg.h> 124 #include <dev/pcmcia/if_cnwioctl.h> 125 126 #include <dev/pcmcia/pcmciareg.h> 127 #include <dev/pcmcia/pcmciavar.h> 128 #include <dev/pcmcia/pcmciadevs.h> 129 130 #include <net/if_dl.h> 131 #include <net/if_ether.h> 132 #include <net/bpf.h> 133 134 #ifdef INET 135 #include <netinet/in.h> 136 #include <netinet/in_systm.h> 137 #include <netinet/in_var.h> 138 #include <netinet/ip.h> 139 #include <netinet/if_inarp.h> 140 #endif 141 142 /* 143 * Let these be patchable variables, initialized from macros that can 144 * be set in the kernel config file. Someone with lots of spare time 145 * could probably write a nice Netwave configuration program to do 146 * this a little bit more elegantly :-). 147 */ 148 #ifndef CNW_DOMAIN 149 #define CNW_DOMAIN 0x100 150 #endif 151 int cnw_domain = CNW_DOMAIN; /* Domain */ 152 #ifndef CNW_SCRAMBLEKEY 153 #define CNW_SCRAMBLEKEY 0 154 #endif 155 int cnw_skey = CNW_SCRAMBLEKEY; /* Scramble key */ 156 157 /* 158 * The card appears to work much better when we only allow one packet 159 * "in the air" at a time. This is done by not allowing another packet 160 * on the card, even if there is room. Turning this off will allow the 161 * driver to stuff packets on the card as soon as a transmit buffer is 162 * available. This does increase the number of collisions, though. 163 * We can que a second packet if there are transmit buffers available, 164 * but we do not actually send the packet until the last packet has 165 * been written. 166 */ 167 #define ONE_AT_A_TIME 168 169 /* 170 * Netwave cards choke if we try to use io memory address >= 0x400. 171 * Even though, CIS tuple does not talk about this. 172 * Use memory mapped access. 173 */ 174 #define MEMORY_MAPPED 175 176 static int cnw_match(device_t, cfdata_t, void *); 177 static void cnw_attach(device_t, device_t, void *); 178 static int cnw_detach(device_t, int); 179 180 static int cnw_activate(device_t, enum devact); 181 182 struct cnw_softc { 183 device_t sc_dev; /* Device glue (must be first) */ 184 struct ethercom sc_ethercom; /* Ethernet common part */ 185 int sc_domain; /* Netwave domain */ 186 int sc_skey; /* Netwave scramble key */ 187 struct cnwstats sc_stats; 188 189 /* PCMCIA-specific stuff */ 190 struct pcmcia_function *sc_pf; /* PCMCIA function */ 191 #ifndef MEMORY_MAPPED 192 struct pcmcia_io_handle sc_pcioh; /* PCMCIA I/O space handle */ 193 int sc_iowin; /* ...window */ 194 bus_space_tag_t sc_iot; /* ...bus_space tag */ 195 bus_space_handle_t sc_ioh; /* ...bus_space handle */ 196 #endif 197 struct pcmcia_mem_handle sc_pcmemh; /* PCMCIA memory handle */ 198 bus_size_t sc_memoff; /* ...offset */ 199 int sc_memwin; /* ...window */ 200 bus_space_tag_t sc_memt; /* ...bus_space tag */ 201 bus_space_handle_t sc_memh; /* ...bus_space handle */ 202 void *sc_ih; /* Interrupt cookie */ 203 struct timeval sc_txlast; /* When the last xmit was made */ 204 int sc_active; /* Currently xmitting a packet */ 205 206 int sc_resource; /* Resources alloc'ed on attach */ 207 #define CNW_RES_PCIC 1 208 #define CNW_RES_IO 2 209 #define CNW_RES_MEM 4 210 #define CNW_RES_NET 8 211 }; 212 213 CFATTACH_DECL_NEW(cnw, sizeof(struct cnw_softc), 214 cnw_match, cnw_attach, cnw_detach, cnw_activate); 215 216 static void cnw_reset(struct cnw_softc *); 217 static void cnw_init(struct cnw_softc *); 218 static int cnw_enable(struct cnw_softc *sc); 219 static void cnw_disable(struct cnw_softc *sc); 220 static void cnw_start(struct ifnet *); 221 static void cnw_transmit(struct cnw_softc *, struct mbuf *); 222 static struct mbuf *cnw_read(struct cnw_softc *); 223 static void cnw_recv(struct cnw_softc *); 224 static int cnw_intr(void *arg); 225 static int cnw_ioctl(struct ifnet *, u_long, void *); 226 static void cnw_watchdog(struct ifnet *); 227 static int cnw_setdomain(struct cnw_softc *, int); 228 static int cnw_setkey(struct cnw_softc *, int); 229 230 /* ---------------------------------------------------------------- */ 231 232 /* Help routines */ 233 static int wait_WOC(struct cnw_softc *, int); 234 static int read16(struct cnw_softc *, int); 235 static int cnw_cmd(struct cnw_softc *, int, int, int, int); 236 237 /* 238 * Wait until the WOC (Write Operation Complete) bit in the 239 * ASR (Adapter Status Register) is asserted. 240 */ 241 static int 242 wait_WOC(struct cnw_softc *sc, int line) 243 { 244 int i, asr; 245 246 for (i = 0; i < 5000; i++) { 247 #ifndef MEMORY_MAPPED 248 asr = bus_space_read_1(sc->sc_iot, sc->sc_ioh, CNW_REG_ASR); 249 #else 250 asr = bus_space_read_1(sc->sc_memt, sc->sc_memh, 251 sc->sc_memoff + CNW_IOM_OFF + CNW_REG_ASR); 252 #endif 253 if (asr & CNW_ASR_WOC) 254 return (0); 255 DELAY(100); 256 } 257 if (line > 0) 258 printf("%s: wedged at line %d\n", device_xname(sc->sc_dev), line); 259 return (1); 260 } 261 #define WAIT_WOC(sc) wait_WOC(sc, __LINE__) 262 263 264 /* 265 * Read a 16 bit value from the card. 266 */ 267 static int 268 read16(struct cnw_softc *sc, int offset) 269 { 270 int hi, lo; 271 int offs = sc->sc_memoff + offset; 272 273 /* This could presumably be done more efficient with 274 * bus_space_read_2(), but I don't know anything about the 275 * byte sex guarantees... Besides, this is pretty cheap as 276 * well :-) 277 */ 278 lo = bus_space_read_1(sc->sc_memt, sc->sc_memh, offs); 279 hi = bus_space_read_1(sc->sc_memt, sc->sc_memh, offs + 1); 280 return ((hi << 8) | lo); 281 } 282 283 284 /* 285 * Send a command to the card by writing it to the command buffer. 286 */ 287 int 288 cnw_cmd(struct cnw_softc *sc, int cmd, int count, int arg1, int arg2) 289 { 290 int ptr = sc->sc_memoff + CNW_EREG_CB; 291 292 if (wait_WOC(sc, 0)) { 293 printf("%s: wedged when issuing cmd 0x%x\n", 294 device_xname(sc->sc_dev), cmd); 295 /* 296 * We'll continue anyway, as that's probably the best 297 * thing we can do; at least the user knows there's a 298 * problem, and can reset the interface with ifconfig 299 * down/up. 300 */ 301 } 302 303 bus_space_write_1(sc->sc_memt, sc->sc_memh, ptr, cmd); 304 if (count > 0) { 305 bus_space_write_1(sc->sc_memt, sc->sc_memh, ptr + 1, arg1); 306 if (count > 1) 307 bus_space_write_1(sc->sc_memt, sc->sc_memh, 308 ptr + 2, arg2); 309 } 310 bus_space_write_1(sc->sc_memt, sc->sc_memh, 311 ptr + count + 1, CNW_CMD_EOC); 312 return (0); 313 } 314 #define CNW_CMD0(sc, cmd) \ 315 do { cnw_cmd(sc, cmd, 0, 0, 0); } while (0) 316 #define CNW_CMD1(sc, cmd, arg1) \ 317 do { cnw_cmd(sc, cmd, 1, arg1 , 0); } while (0) 318 #define CNW_CMD2(sc, cmd, arg1, arg2) \ 319 do { cnw_cmd(sc, cmd, 2, arg1, arg2); } while (0) 320 321 /* ---------------------------------------------------------------- */ 322 323 /* 324 * Reset the hardware. 325 */ 326 static void 327 cnw_reset(struct cnw_softc *sc) 328 { 329 #ifdef CNW_DEBUG 330 if (sc->sc_ethercom.ec_if.if_flags & IFF_DEBUG) 331 printf("%s: resetting\n", device_xname(sc->sc_dev)); 332 #endif 333 wait_WOC(sc, 0); 334 #ifndef MEMORY_MAPPED 335 bus_space_write_1(sc->sc_iot, sc->sc_ioh, CNW_REG_PMR, CNW_PMR_RESET); 336 #else 337 bus_space_write_1(sc->sc_memt, sc->sc_memh, 338 sc->sc_memoff + CNW_IOM_OFF + CNW_REG_PMR, CNW_PMR_RESET); 339 #endif 340 bus_space_write_1(sc->sc_memt, sc->sc_memh, 341 sc->sc_memoff + CNW_EREG_ASCC, CNW_ASR_WOC); 342 #ifndef MEMORY_MAPPED 343 bus_space_write_1(sc->sc_iot, sc->sc_ioh, CNW_REG_PMR, 0); 344 #else 345 bus_space_write_1(sc->sc_memt, sc->sc_memh, 346 sc->sc_memoff + CNW_IOM_OFF + CNW_REG_PMR, 0); 347 #endif 348 } 349 350 351 /* 352 * Initialize the card. 353 */ 354 static void 355 cnw_init(struct cnw_softc *sc) 356 { 357 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 358 const u_int8_t rxmode = 359 CNW_RXCONF_RXENA | CNW_RXCONF_BCAST | CNW_RXCONF_AMP; 360 361 /* Reset the card */ 362 cnw_reset(sc); 363 364 /* Issue a NOP to check the card */ 365 CNW_CMD0(sc, CNW_CMD_NOP); 366 367 /* Set up receive configuration */ 368 CNW_CMD1(sc, CNW_CMD_SRC, 369 rxmode | ((ifp->if_flags & IFF_PROMISC) ? CNW_RXCONF_PRO : 0)); 370 371 /* Set up transmit configuration */ 372 CNW_CMD1(sc, CNW_CMD_STC, CNW_TXCONF_TXENA); 373 374 /* Set domain */ 375 CNW_CMD2(sc, CNW_CMD_SMD, sc->sc_domain, sc->sc_domain >> 8); 376 377 /* Set scramble key */ 378 CNW_CMD2(sc, CNW_CMD_SSK, sc->sc_skey, sc->sc_skey >> 8); 379 380 /* Enable interrupts */ 381 WAIT_WOC(sc); 382 #ifndef MEMORY_MAPPED 383 bus_space_write_1(sc->sc_iot, sc->sc_ioh, 384 CNW_REG_IMR, CNW_IMR_IENA | CNW_IMR_RFU1); 385 #else 386 bus_space_write_1(sc->sc_memt, sc->sc_memh, 387 sc->sc_memoff + CNW_IOM_OFF + CNW_REG_IMR, 388 CNW_IMR_IENA | CNW_IMR_RFU1); 389 #endif 390 391 /* Enable receiver */ 392 CNW_CMD0(sc, CNW_CMD_ER); 393 394 /* "Set the IENA bit in COR" */ 395 WAIT_WOC(sc); 396 #ifndef MEMORY_MAPPED 397 bus_space_write_1(sc->sc_iot, sc->sc_ioh, CNW_REG_COR, 398 CNW_COR_IENA | CNW_COR_LVLREQ); 399 #else 400 bus_space_write_1(sc->sc_memt, sc->sc_memh, 401 sc->sc_memoff + CNW_IOM_OFF + CNW_REG_COR, 402 CNW_COR_IENA | CNW_COR_LVLREQ); 403 #endif 404 } 405 406 407 /* 408 * Enable and initialize the card. 409 */ 410 static int 411 cnw_enable(struct cnw_softc *sc) 412 { 413 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 414 415 if ((ifp->if_flags & IFF_RUNNING) != 0) 416 return (0); 417 418 sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_NET, cnw_intr, sc); 419 if (sc->sc_ih == NULL) { 420 aprint_error_dev(sc->sc_dev, "couldn't establish interrupt handler\n"); 421 return (EIO); 422 } 423 if (pcmcia_function_enable(sc->sc_pf) != 0) { 424 aprint_error_dev(sc->sc_dev, "couldn't enable card\n"); 425 return (EIO); 426 } 427 sc->sc_resource |= CNW_RES_PCIC; 428 cnw_init(sc); 429 ifp->if_flags &= ~IFF_OACTIVE; 430 ifp->if_flags |= IFF_RUNNING; 431 return (0); 432 } 433 434 435 /* 436 * Stop and disable the card. 437 */ 438 static void 439 cnw_disable(struct cnw_softc *sc) 440 { 441 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 442 443 if ((ifp->if_flags & IFF_RUNNING) == 0) 444 return; 445 446 pcmcia_function_disable(sc->sc_pf); 447 sc->sc_resource &= ~CNW_RES_PCIC; 448 pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih); 449 ifp->if_flags &= ~IFF_RUNNING; 450 ifp->if_timer = 0; 451 } 452 453 454 /* 455 * Match the hardware we handle. 456 */ 457 static int 458 cnw_match(device_t parent, cfdata_t match, void *aux) 459 { 460 struct pcmcia_attach_args *pa = aux; 461 462 if (pa->manufacturer == PCMCIA_VENDOR_XIRCOM && 463 pa->product == PCMCIA_PRODUCT_XIRCOM_CNW_801) 464 return 1; 465 if (pa->manufacturer == PCMCIA_VENDOR_XIRCOM && 466 pa->product == PCMCIA_PRODUCT_XIRCOM_CNW_802) 467 return 1; 468 return 0; 469 } 470 471 472 /* 473 * Attach the card. 474 */ 475 static void 476 cnw_attach(device_t parent, device_t self, void *aux) 477 { 478 struct cnw_softc *sc = device_private(self); 479 struct pcmcia_attach_args *pa = aux; 480 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 481 u_int8_t macaddr[ETHER_ADDR_LEN]; 482 int i; 483 bus_size_t memsize; 484 485 sc->sc_dev = self; 486 sc->sc_resource = 0; 487 488 /* Enable the card */ 489 sc->sc_pf = pa->pf; 490 pcmcia_function_init(sc->sc_pf, SIMPLEQ_FIRST(&sc->sc_pf->cfe_head)); 491 if (pcmcia_function_enable(sc->sc_pf)) { 492 aprint_error_dev(self, "function enable failed\n"); 493 return; 494 } 495 sc->sc_resource |= CNW_RES_PCIC; 496 497 /* Map I/O register and "memory" */ 498 #ifndef MEMORY_MAPPED 499 if (pcmcia_io_alloc(sc->sc_pf, 0, CNW_IO_SIZE, CNW_IO_SIZE, 500 &sc->sc_pcioh) != 0) { 501 aprint_error_dev(self, "can't allocate i/o space\n"); 502 goto fail; 503 } 504 if (pcmcia_io_map(sc->sc_pf, PCMCIA_WIDTH_IO16, &sc->sc_pcioh, 505 &sc->sc_iowin) != 0) { 506 aprint_error_dev(self, "can't map i/o space\n"); 507 pcmcia_io_free(sc->sc_pf, &sc->sc_pcioh); 508 goto fail; 509 } 510 sc->sc_iot = sc->sc_pcioh.iot; 511 sc->sc_ioh = sc->sc_pcioh.ioh; 512 sc->sc_resource |= CNW_RES_IO; 513 #endif 514 #ifndef MEMORY_MAPPED 515 memsize = CNW_MEM_SIZE; 516 #else 517 memsize = CNW_MEM_SIZE + CNW_IOM_SIZE; 518 #endif 519 if (pcmcia_mem_alloc(sc->sc_pf, memsize, &sc->sc_pcmemh) != 0) { 520 aprint_error_dev(self, "can't allocate memory\n"); 521 goto fail; 522 } 523 if (pcmcia_mem_map(sc->sc_pf, PCMCIA_WIDTH_MEM8|PCMCIA_MEM_COMMON, 524 CNW_MEM_ADDR, memsize, &sc->sc_pcmemh, &sc->sc_memoff, 525 &sc->sc_memwin) != 0) { 526 aprint_error_dev(self, "can't map memory\n"); 527 pcmcia_mem_free(sc->sc_pf, &sc->sc_pcmemh); 528 goto fail; 529 } 530 sc->sc_memt = sc->sc_pcmemh.memt; 531 sc->sc_memh = sc->sc_pcmemh.memh; 532 sc->sc_resource |= CNW_RES_MEM; 533 534 /* Finish setup of softc */ 535 sc->sc_domain = cnw_domain; 536 sc->sc_skey = cnw_skey; 537 538 /* Get MAC address */ 539 cnw_reset(sc); 540 for (i = 0; i < ETHER_ADDR_LEN; i++) 541 macaddr[i] = bus_space_read_1(sc->sc_memt, sc->sc_memh, 542 sc->sc_memoff + CNW_EREG_PA + i); 543 printf("%s: address %s\n", device_xname(sc->sc_dev), 544 ether_sprintf(macaddr)); 545 546 /* Set up ifnet structure */ 547 strlcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ); 548 ifp->if_softc = sc; 549 ifp->if_start = cnw_start; 550 ifp->if_ioctl = cnw_ioctl; 551 ifp->if_watchdog = cnw_watchdog; 552 ifp->if_flags = IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX; 553 IFQ_SET_READY(&ifp->if_snd); 554 555 /* Attach the interface */ 556 if_attach(ifp); 557 if_deferred_start_init(ifp, NULL); 558 ether_ifattach(ifp, macaddr); 559 560 sc->sc_resource |= CNW_RES_NET; 561 562 ifp->if_baudrate = IF_Mbps(1); 563 564 /* Disable the card now, and turn it on when the interface goes up */ 565 pcmcia_function_disable(sc->sc_pf); 566 sc->sc_resource &= ~CNW_RES_PCIC; 567 return; 568 569 fail: 570 #ifndef MEMORY_MAPPED 571 if ((sc->sc_resource & CNW_RES_IO) != 0) { 572 pcmcia_io_unmap(sc->sc_pf, sc->sc_iowin); 573 pcmcia_io_free(sc->sc_pf, &sc->sc_pcioh); 574 sc->sc_resource &= ~CNW_RES_IO; 575 } 576 #endif 577 if ((sc->sc_resource & CNW_RES_PCIC) != 0) { 578 pcmcia_function_disable(sc->sc_pf); 579 sc->sc_resource &= ~CNW_RES_PCIC; 580 } 581 } 582 583 /* 584 * Start outputting on the interface. 585 */ 586 static void 587 cnw_start(struct ifnet *ifp) 588 { 589 struct cnw_softc *sc = ifp->if_softc; 590 struct mbuf *m0; 591 int lif; 592 int asr; 593 #ifdef ONE_AT_A_TIME 594 struct timeval now; 595 #endif 596 597 #ifdef CNW_DEBUG 598 if (sc->sc_ethercom.ec_if.if_flags & IFF_DEBUG) 599 printf("%s: cnw_start\n", ifp->if_xname); 600 if (ifp->if_flags & IFF_OACTIVE) 601 printf("%s: cnw_start reentered\n", ifp->if_xname); 602 #endif 603 604 ifp->if_flags |= IFF_OACTIVE; 605 606 for (;;) { 607 #ifdef ONE_AT_A_TIME 608 microtime(&now); 609 now.tv_sec -= sc->sc_txlast.tv_sec; 610 now.tv_usec -= sc->sc_txlast.tv_usec; 611 if (now.tv_usec < 0) { 612 now.tv_usec += 1000000; 613 now.tv_sec--; 614 } 615 616 /* 617 * Don't ship this packet out until the last 618 * packet has left the building. 619 * If we have not tried to send a packet for 1/5 620 * a second then we assume we lost an interrupt, 621 * lets go on and send the next packet anyhow. 622 * 623 * I suppose we could check to see if it is okay 624 * to put additional packets on the card (beyond 625 * the one already waiting to be sent) but I don't 626 * think we would get any improvement in speed as 627 * we should have ample time to put the next packet 628 * on while this one is going out. 629 */ 630 if (sc->sc_active && now.tv_sec == 0 && now.tv_usec < 200000) 631 break; 632 #endif 633 634 /* Make sure the link integrity field is on */ 635 WAIT_WOC(sc); 636 lif = bus_space_read_1(sc->sc_memt, sc->sc_memh, 637 sc->sc_memoff + CNW_EREG_LIF); 638 if (lif == 0) { 639 #ifdef CNW_DEBUG 640 if (sc->sc_ethercom.ec_if.if_flags & IFF_DEBUG) 641 printf("%s: link integrity %d\n", ifp->if_xname, lif); 642 #endif 643 break; 644 } 645 646 /* Is there any buffer space available on the card? */ 647 WAIT_WOC(sc); 648 #ifndef MEMORY_MAPPED 649 asr = bus_space_read_1(sc->sc_iot, sc->sc_ioh, CNW_REG_ASR); 650 #else 651 asr = bus_space_read_1(sc->sc_memt, sc->sc_memh, 652 sc->sc_memoff + CNW_IOM_OFF + CNW_REG_ASR); 653 #endif 654 if (!(asr & CNW_ASR_TXBA)) { 655 #ifdef CNW_DEBUG 656 if (sc->sc_ethercom.ec_if.if_flags & IFF_DEBUG) 657 printf("%s: no buffer space\n", ifp->if_xname); 658 #endif 659 break; 660 } 661 662 sc->sc_stats.nws_tx++; 663 664 IFQ_DEQUEUE(&ifp->if_snd, m0); 665 if (m0 == 0) 666 break; 667 668 bpf_mtap(ifp, m0, BPF_D_OUT); 669 670 cnw_transmit(sc, m0); 671 if_statinc(ifp, if_opackets); 672 ifp->if_timer = 3; /* start watchdog timer */ 673 674 microtime(&sc->sc_txlast); 675 sc->sc_active = 1; 676 } 677 678 ifp->if_flags &= ~IFF_OACTIVE; 679 } 680 681 /* 682 * Transmit a packet. 683 */ 684 static void 685 cnw_transmit(struct cnw_softc *sc, struct mbuf *m0) 686 { 687 int buffer, bufsize, bufoffset, bufptr, bufspace, len, mbytes, n; 688 struct mbuf *m; 689 u_int8_t *mptr; 690 691 /* Get buffer info from card */ 692 buffer = read16(sc, CNW_EREG_TDP); 693 bufsize = read16(sc, CNW_EREG_TDP + 2); 694 bufoffset = read16(sc, CNW_EREG_TDP + 4); 695 #ifdef CNW_DEBUG 696 if (sc->sc_ethercom.ec_if.if_flags & IFF_DEBUG) 697 printf("%s: cnw_transmit b=0x%x s=%d o=0x%x\n", 698 device_xname(sc->sc_dev), buffer, bufsize, bufoffset); 699 #endif 700 701 /* Copy data from mbuf chain to card buffers */ 702 bufptr = sc->sc_memoff + buffer + bufoffset; 703 bufspace = bufsize; 704 len = 0; 705 for (m = m0; m; ) { 706 mptr = mtod(m, u_int8_t *); 707 mbytes = m->m_len; 708 len += mbytes; 709 while (mbytes > 0) { 710 if (bufspace == 0) { 711 buffer = read16(sc, buffer); 712 bufptr = sc->sc_memoff + buffer + bufoffset; 713 bufspace = bufsize; 714 #ifdef CNW_DEBUG 715 if (sc->sc_ethercom.ec_if.if_flags & IFF_DEBUG) 716 printf("%s: next buffer @0x%x\n", 717 device_xname(sc->sc_dev), buffer); 718 #endif 719 } 720 n = mbytes <= bufspace ? mbytes : bufspace; 721 bus_space_write_region_1(sc->sc_memt, sc->sc_memh, 722 bufptr, mptr, n); 723 bufptr += n; 724 bufspace -= n; 725 mptr += n; 726 mbytes -= n; 727 } 728 m = m0 = m_free(m); 729 } 730 731 /* Issue transmit command */ 732 CNW_CMD2(sc, CNW_CMD_TL, len, len >> 8); 733 } 734 735 736 /* 737 * Pull a packet from the card into an mbuf chain. 738 */ 739 static struct mbuf * 740 cnw_read(struct cnw_softc *sc) 741 { 742 struct mbuf *m, *top, **mp; 743 int totbytes, buffer, bufbytes, bufptr, mbytes, n; 744 u_int8_t *mptr; 745 746 WAIT_WOC(sc); 747 totbytes = read16(sc, CNW_EREG_RDP); 748 #ifdef CNW_DEBUG 749 if (sc->sc_ethercom.ec_if.if_flags & IFF_DEBUG) 750 printf("%s: recv %d bytes\n", device_xname(sc->sc_dev), totbytes); 751 #endif 752 buffer = CNW_EREG_RDP + 2; 753 bufbytes = 0; 754 bufptr = 0; /* XXX make gcc happy */ 755 756 MGETHDR(m, M_DONTWAIT, MT_DATA); 757 if (m == 0) 758 return (0); 759 m_set_rcvif(m, &sc->sc_ethercom.ec_if); 760 m->m_pkthdr.len = totbytes; 761 mbytes = MHLEN; 762 top = 0; 763 mp = ⊤ 764 765 while (totbytes > 0) { 766 if (top) { 767 MGET(m, M_DONTWAIT, MT_DATA); 768 if (m == 0) { 769 m_freem(top); 770 return (0); 771 } 772 mbytes = MLEN; 773 } 774 if (totbytes >= MINCLSIZE) { 775 MCLGET(m, M_DONTWAIT); 776 if ((m->m_flags & M_EXT) == 0) { 777 m_free(m); 778 m_freem(top); 779 return (0); 780 } 781 mbytes = MCLBYTES; 782 } 783 if (!top) { 784 int pad = ALIGN(sizeof(struct ether_header)) - 785 sizeof(struct ether_header); 786 m->m_data += pad; 787 mbytes -= pad; 788 } 789 mptr = mtod(m, u_int8_t *); 790 mbytes = m->m_len = uimin(totbytes, mbytes); 791 totbytes -= mbytes; 792 while (mbytes > 0) { 793 if (bufbytes == 0) { 794 buffer = read16(sc, buffer); 795 bufbytes = read16(sc, buffer + 2); 796 bufptr = sc->sc_memoff + buffer + 797 read16(sc, buffer + 4); 798 #ifdef CNW_DEBUG 799 if (sc->sc_ethercom.ec_if.if_flags & IFF_DEBUG) 800 printf("%s: %d bytes @0x%x+0x%lx\n", 801 device_xname(sc->sc_dev), bufbytes, 802 buffer, (u_long)(bufptr - buffer - 803 sc->sc_memoff)); 804 #endif 805 } 806 n = mbytes <= bufbytes ? mbytes : bufbytes; 807 bus_space_read_region_1(sc->sc_memt, sc->sc_memh, 808 bufptr, mptr, n); 809 bufbytes -= n; 810 bufptr += n; 811 mbytes -= n; 812 mptr += n; 813 } 814 *mp = m; 815 mp = &m->m_next; 816 } 817 818 return (top); 819 } 820 821 822 /* 823 * Handle received packets. 824 */ 825 static void 826 cnw_recv(struct cnw_softc *sc) 827 { 828 int rser; 829 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 830 struct mbuf *m; 831 832 for (;;) { 833 WAIT_WOC(sc); 834 rser = bus_space_read_1(sc->sc_memt, sc->sc_memh, 835 sc->sc_memoff + CNW_EREG_RSER); 836 if (!(rser & CNW_RSER_RXAVAIL)) 837 return; 838 839 /* Pull packet off card */ 840 m = cnw_read(sc); 841 842 /* Acknowledge packet */ 843 CNW_CMD0(sc, CNW_CMD_SRP); 844 845 /* Did we manage to get the packet from the interface? */ 846 if (m == 0) { 847 if_statinc(ifp, if_ierrors); 848 return; 849 } 850 851 /* Pass the packet up. */ 852 if_percpuq_enqueue(ifp->if_percpuq, m); 853 } 854 } 855 856 857 /* 858 * Interrupt handler. 859 */ 860 static int 861 cnw_intr(void *arg) 862 { 863 struct cnw_softc *sc = arg; 864 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 865 int ret, status, rser, tser; 866 867 if ((sc->sc_ethercom.ec_if.if_flags & IFF_RUNNING) == 0 || 868 !device_is_active(sc->sc_dev)) 869 return (0); 870 ifp->if_timer = 0; /* stop watchdog timer */ 871 872 ret = 0; 873 for (;;) { 874 WAIT_WOC(sc); 875 #ifndef MEMORY_MAPPED 876 status = bus_space_read_1(sc->sc_iot, sc->sc_ioh, 877 CNW_REG_CCSR); 878 #else 879 status = bus_space_read_1(sc->sc_memt, sc->sc_memh, 880 sc->sc_memoff + CNW_IOM_OFF + CNW_REG_CCSR); 881 #endif 882 if (!(status & 0x02)) 883 /* No more commands, or shared IRQ */ 884 return (ret); 885 ret = 1; 886 #ifndef MEMORY_MAPPED 887 status = bus_space_read_1(sc->sc_iot, sc->sc_ioh, CNW_REG_ASR); 888 #else 889 status = bus_space_read_1(sc->sc_memt, sc->sc_memh, 890 sc->sc_memoff + CNW_IOM_OFF + CNW_REG_ASR); 891 #endif 892 893 /* Anything to receive? */ 894 if (status & CNW_ASR_RXRDY) { 895 sc->sc_stats.nws_rx++; 896 cnw_recv(sc); 897 } 898 899 /* Receive error */ 900 if (status & CNW_ASR_RXERR) { 901 /* 902 * I get a *lot* of spurious receive errors 903 * (many per second), even when the interface 904 * is quiescent, so we don't increment 905 * if_ierrors here. 906 */ 907 rser = bus_space_read_1(sc->sc_memt, sc->sc_memh, 908 sc->sc_memoff + CNW_EREG_RSER); 909 910 /* RX statistics */ 911 sc->sc_stats.nws_rxerr++; 912 if (rser & CNW_RSER_RXBIG) 913 sc->sc_stats.nws_rxframe++; 914 if (rser & CNW_RSER_RXCRC) 915 sc->sc_stats.nws_rxcrcerror++; 916 if (rser & CNW_RSER_RXOVERRUN) 917 sc->sc_stats.nws_rxoverrun++; 918 if (rser & CNW_RSER_RXOVERFLOW) 919 sc->sc_stats.nws_rxoverflow++; 920 if (rser & CNW_RSER_RXERR) 921 sc->sc_stats.nws_rxerrors++; 922 if (rser & CNW_RSER_RXAVAIL) 923 sc->sc_stats.nws_rxavail++; 924 925 /* Clear error bits in RSER */ 926 WAIT_WOC(sc); 927 bus_space_write_1(sc->sc_memt, sc->sc_memh, 928 sc->sc_memoff + CNW_EREG_RSERW, 929 CNW_RSER_RXERR | 930 (rser & (CNW_RSER_RXCRC | CNW_RSER_RXBIG))); 931 /* Clear RXERR in ASR */ 932 WAIT_WOC(sc); 933 bus_space_write_1(sc->sc_memt, sc->sc_memh, 934 sc->sc_memoff + CNW_EREG_ASCC, CNW_ASR_RXERR); 935 } 936 937 /* Transmit done */ 938 if (status & CNW_ASR_TXDN) { 939 tser = bus_space_read_1(sc->sc_memt, sc->sc_memh, 940 CNW_EREG_TSER); 941 942 /* TX statistics */ 943 if (tser & CNW_TSER_TXERR) 944 sc->sc_stats.nws_txerrors++; 945 if (tser & CNW_TSER_TXNOAP) 946 sc->sc_stats.nws_txlostcd++; 947 if (tser & CNW_TSER_TXGU) 948 sc->sc_stats.nws_txabort++; 949 950 if (tser & CNW_TSER_TXOK) { 951 sc->sc_stats.nws_txokay++; 952 sc->sc_stats.nws_txretries[status & 0xf]++; 953 WAIT_WOC(sc); 954 bus_space_write_1(sc->sc_memt, sc->sc_memh, 955 sc->sc_memoff + CNW_EREG_TSERW, 956 CNW_TSER_TXOK | CNW_TSER_RTRY); 957 } 958 959 if (tser & CNW_TSER_ERROR) { 960 if_statinc(ifp, if_oerrors); 961 WAIT_WOC(sc); 962 bus_space_write_1(sc->sc_memt, sc->sc_memh, 963 sc->sc_memoff + CNW_EREG_TSERW, 964 (tser & CNW_TSER_ERROR) | 965 CNW_TSER_RTRY); 966 } 967 968 sc->sc_active = 0; 969 ifp->if_flags &= ~IFF_OACTIVE; 970 971 /* Continue to send packets from the queue */ 972 if_schedule_deferred_start(&sc->sc_ethercom.ec_if); 973 } 974 975 } 976 } 977 978 979 /* 980 * Handle device ioctls. 981 */ 982 static int 983 cnw_ioctl(struct ifnet *ifp, u_long cmd, void *data) 984 { 985 struct cnw_softc *sc = ifp->if_softc; 986 struct ifaddr *ifa = (struct ifaddr *)data; 987 struct ifreq *ifr = (struct ifreq *)data; 988 int s, error = 0; 989 struct lwp *l = curlwp; /*XXX*/ 990 991 switch (cmd) { 992 case SIOCINITIFADDR: 993 case SIOCSIFFLAGS: 994 case SIOCADDMULTI: 995 case SIOCDELMULTI: 996 case SIOCGCNWDOMAIN: 997 case SIOCGCNWSTATS: 998 break; 999 case SIOCSCNWDOMAIN: 1000 case SIOCSCNWKEY: 1001 error = kauth_authorize_network(l->l_cred, 1002 KAUTH_NETWORK_INTERFACE, 1003 KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp, KAUTH_ARG(cmd), 1004 NULL); 1005 if (error) 1006 return (error); 1007 break; 1008 case SIOCGCNWSTATUS: 1009 error = kauth_authorize_network(l->l_cred, 1010 KAUTH_NETWORK_INTERFACE, 1011 KAUTH_REQ_NETWORK_INTERFACE_GETPRIV, ifp, KAUTH_ARG(cmd), 1012 NULL); 1013 if (error) 1014 return (error); 1015 break; 1016 default: 1017 return (EINVAL); 1018 } 1019 1020 s = splnet(); 1021 1022 switch (cmd) { 1023 1024 case SIOCINITIFADDR: 1025 if (!(ifp->if_flags & IFF_RUNNING) && 1026 (error = cnw_enable(sc)) != 0) 1027 break; 1028 ifp->if_flags |= IFF_UP; 1029 cnw_init(sc); 1030 switch (ifa->ifa_addr->sa_family) { 1031 #ifdef INET 1032 case AF_INET: 1033 arp_ifinit(&sc->sc_ethercom.ec_if, ifa); 1034 break; 1035 #endif 1036 default: 1037 break; 1038 } 1039 break; 1040 1041 case SIOCSIFFLAGS: 1042 if ((error = ifioctl_common(ifp, cmd, data)) != 0) 1043 break; 1044 /* XXX re-use ether_ioctl() */ 1045 switch (ifp->if_flags & (IFF_UP|IFF_RUNNING)) { 1046 case IFF_RUNNING: 1047 /* 1048 * The interface is marked down and it is running, so 1049 * stop it. 1050 */ 1051 cnw_disable(sc); 1052 break; 1053 case IFF_UP: 1054 /* 1055 * The interface is marked up and it is stopped, so 1056 * start it. 1057 */ 1058 error = cnw_enable(sc); 1059 break; 1060 default: 1061 /* IFF_PROMISC may be changed */ 1062 cnw_init(sc); 1063 break; 1064 } 1065 break; 1066 1067 case SIOCADDMULTI: 1068 case SIOCDELMULTI: 1069 /* Update our multicast list. */ 1070 if ((error = ether_ioctl(ifp, cmd, data)) == ENETRESET) { 1071 if (ifp->if_flags & IFF_RUNNING) 1072 cnw_init(sc); 1073 error = 0; 1074 } 1075 break; 1076 1077 case SIOCGCNWDOMAIN: 1078 ifr->ifr_domain = sc->sc_domain; 1079 break; 1080 1081 case SIOCSCNWDOMAIN: 1082 error = cnw_setdomain(sc, ifr->ifr_domain); 1083 break; 1084 1085 case SIOCSCNWKEY: 1086 error = cnw_setkey(sc, ifr->ifr_key); 1087 break; 1088 1089 case SIOCGCNWSTATUS: 1090 if ((ifp->if_flags & IFF_RUNNING) == 0) 1091 break; 1092 bus_space_read_region_1(sc->sc_memt, sc->sc_memh, 1093 sc->sc_memoff + CNW_EREG_CB, 1094 ((struct cnwstatus *)data)->data, 1095 sizeof(((struct cnwstatus *)data)->data)); 1096 break; 1097 1098 case SIOCGCNWSTATS: 1099 memcpy((void *)&(((struct cnwistats *)data)->stats), 1100 (void *)&sc->sc_stats, sizeof(struct cnwstats)); 1101 break; 1102 1103 default: 1104 error = ether_ioctl(ifp, cmd, data); 1105 break; 1106 } 1107 1108 splx(s); 1109 return (error); 1110 } 1111 1112 1113 /* 1114 * Device timeout/watchdog routine. Entered if the device neglects to 1115 * generate an interrupt after a transmit has been started on it. 1116 */ 1117 static void 1118 cnw_watchdog(struct ifnet *ifp) 1119 { 1120 struct cnw_softc *sc = ifp->if_softc; 1121 1122 printf("%s: device timeout; card reset\n", device_xname(sc->sc_dev)); 1123 if_statinc(ifp, if_oerrors); 1124 cnw_init(sc); 1125 } 1126 1127 static int 1128 cnw_setdomain(struct cnw_softc *sc, int domain) 1129 { 1130 int s; 1131 1132 if (domain & ~0x1ff) 1133 return EINVAL; 1134 1135 s = splnet(); 1136 CNW_CMD2(sc, CNW_CMD_SMD, domain, domain >> 8); 1137 splx(s); 1138 1139 sc->sc_domain = domain; 1140 return 0; 1141 } 1142 1143 static int 1144 cnw_setkey(struct cnw_softc *sc, int key) 1145 { 1146 int s; 1147 1148 if (key & ~0xffff) 1149 return EINVAL; 1150 1151 s = splnet(); 1152 CNW_CMD2(sc, CNW_CMD_SSK, key, key >> 8); 1153 splx(s); 1154 1155 sc->sc_skey = key; 1156 return 0; 1157 } 1158 1159 static int 1160 cnw_activate(device_t self, enum devact act) 1161 { 1162 struct cnw_softc *sc = device_private(self); 1163 1164 switch (act) { 1165 case DVACT_DEACTIVATE: 1166 if_deactivate(&sc->sc_ethercom.ec_if); 1167 return 0; 1168 default: 1169 return EOPNOTSUPP; 1170 } 1171 } 1172 1173 static int 1174 cnw_detach(device_t self, int flags) 1175 { 1176 struct cnw_softc *sc = device_private(self); 1177 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 1178 1179 /* cnw_disable() checks IFF_RUNNING */ 1180 cnw_disable(sc); 1181 1182 if ((sc->sc_resource & CNW_RES_NET) != 0) { 1183 ether_ifdetach(ifp); 1184 if_detach(ifp); 1185 } 1186 1187 #ifndef MEMORY_MAPPED 1188 /* unmap and free our i/o windows */ 1189 if ((sc->sc_resource & CNW_RES_IO) != 0) { 1190 pcmcia_io_unmap(sc->sc_pf, sc->sc_iowin); 1191 pcmcia_io_free(sc->sc_pf, &sc->sc_pcioh); 1192 } 1193 #endif 1194 1195 /* unmap and free our memory windows */ 1196 if ((sc->sc_resource & CNW_RES_MEM) != 0) { 1197 pcmcia_mem_unmap(sc->sc_pf, sc->sc_memwin); 1198 pcmcia_mem_free(sc->sc_pf, &sc->sc_pcmemh); 1199 } 1200 1201 return (0); 1202 } 1203
Indexes created Sun Sep 21 20:09:37 GMT 2025