![[BACK]](/icons/back.gif){kind=icon}
Return to if_cnw.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pcmcia|
Return to if_cnw.c CVS log | Up to [local] / sys / dev / pcmcia |
1.1 nbrk 1: /* $OpenBSD: if_cnw.c,v 1.16 2006/03/25 22:41:46 djm Exp $ */
2: /*-
3: * Copyright (c) 1998 The NetBSD Foundation, Inc.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to The NetBSD Foundation
7: * by Michael Eriksson.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by the NetBSD
20: * Foundation, Inc. and its contributors.
21: * 4. Neither the name of The NetBSD Foundation nor the names of its
22: * contributors may be used to endorse or promote products derived
23: * from this software without specific prior written permission.
24: *
25: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
26: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
27: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
29: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35: * POSSIBILITY OF SUCH DAMAGE.
36: */
37:
38: /*
39: * This is a driver for the Xircom CreditCard Netwave (also known as
40: * the Netwave Airsurfer) wireless LAN PCMCIA adapter.
41: *
42: * When this driver was developed, the Linux Netwave driver was used
43: * as a hardware manual. That driver is Copyright (c) 1997 University
44: * of Tromsų, Norway. It is part of the Linux pcmcia-cs package that
45: * can be found at http://pcmcia-cs.sourceforge.net/. The most
46: * recent version of the pcmcia-cs package when this driver was
47: * written was 3.0.6.
48: *
49: * Unfortunately, a lot of explicit numeric constants were used in the
50: * Linux driver. I have tried to use symbolic names whenever possible,
51: * but since I don't have any real hardware documentation, there's
52: * still one or two "magic numbers" :-(.
53: *
54: * Driver limitations: This driver doesn't do multicasting or receiver
55: * promiscuity, because of missing hardware documentation. I couldn't
56: * get receiver promiscuity to work, and I haven't even tried
57: * multicast. Volunteers are welcome, of course :-).
58: */
59:
60: #include "bpfilter.h"
61:
62: #include <sys/param.h>
63: #include <sys/systm.h>
64: #include <sys/device.h>
65: #include <sys/socket.h>
66: #include <sys/mbuf.h>
67: #include <sys/ioctl.h>
68:
69: #include <dev/pcmcia/if_cnwreg.h>
70:
71: #include <dev/pcmcia/pcmciareg.h>
72: #include <dev/pcmcia/pcmciavar.h>
73: #include <dev/pcmcia/pcmciadevs.h>
74:
75: #include <net/if.h>
76: #include <net/if_dl.h>
77:
78: #ifdef INET
79: #include <netinet/in.h>
80: #include <netinet/in_systm.h>
81: #include <netinet/in_var.h>
82: #include <netinet/ip.h>
83: #include <netinet/if_ether.h>
84: #endif
85:
86: #if NBPFILTER > 0
87: #include <net/bpf.h>
88: #endif
89:
90:
91: /*
92: * Let these be patchable variables, initialized from macros that can
93: * be set in the kernel config file. Someone with lots of spare time
94: * could probably write a nice Netwave configuration program to do
95: * this a little bit more elegantly :-).
96: */
97: #ifndef CNW_DOMAIN
98: #define CNW_DOMAIN 0x100
99: #endif
100: int cnw_domain = CNW_DOMAIN; /* Domain */
101: #ifndef CNW_SCRAMBLEKEY
102: #define CNW_SCRAMBLEKEY 0
103: #endif
104: int cnw_skey = CNW_SCRAMBLEKEY; /* Scramble key */
105:
106:
107: int cnw_match(struct device *, void *, void *);
108: void cnw_attach(struct device *, struct device *, void *);
109: int cnw_detach(struct device *, int);
110: int cnw_activate(struct device *, enum devact);
111:
112: struct cnw_softc {
113: struct device sc_dev; /* Device glue (must be first) */
114: struct arpcom sc_arpcom; /* Ethernet common part */
115: int sc_domain; /* Netwave domain */
116: int sc_skey; /* Netwave scramble key */
117:
118: /* PCMCIA-specific stuff */
119: struct pcmcia_function *sc_pf; /* PCMCIA function */
120: struct pcmcia_io_handle sc_pcioh; /* PCMCIA I/O space handle */
121: int sc_iowin; /* ...window */
122: bus_space_tag_t sc_iot; /* ...bus_space tag */
123: bus_space_handle_t sc_ioh; /* ...bus_space handle */
124: struct pcmcia_mem_handle sc_pcmemh; /* PCMCIA memory handle */
125: bus_addr_t sc_memoff; /* ...offset */
126: int sc_memwin; /* ...window */
127: bus_space_tag_t sc_memt; /* ...bus_space tag */
128: bus_space_handle_t sc_memh; /* ...bus_space handle */
129: void *sc_ih; /* Interrupt cookie */
130: };
131:
132: struct cfattach cnw_ca = {
133: sizeof(struct cnw_softc), cnw_match, cnw_attach,
134: cnw_detach, cnw_activate
135: };
136:
137: struct cfdriver cnw_cd = {
138: NULL, "cnw", DV_IFNET
139: };
140:
141: void cnw_reset(struct cnw_softc *);
142: void cnw_init(struct cnw_softc *);
143: int cnw_enable(struct cnw_softc *sc);
144: void cnw_disable(struct cnw_softc *sc);
145: void cnw_config(struct cnw_softc *sc, u_int8_t *);
146: void cnw_start(struct ifnet *);
147: void cnw_transmit(struct cnw_softc *, struct mbuf *);
148: struct mbuf *cnw_read(struct cnw_softc *);
149: void cnw_recv(struct cnw_softc *);
150: int cnw_intr(void *arg);
151: int cnw_ioctl(struct ifnet *, u_long, caddr_t);
152: void cnw_watchdog(struct ifnet *);
153:
154: /* ---------------------------------------------------------------- */
155:
156: /* Help routines */
157: static int wait_WOC(struct cnw_softc *, int);
158: static int read16(struct cnw_softc *, int);
159: static int cnw_cmd(struct cnw_softc *, int, int, int, int);
160:
161: /*
162: * Wait until the WOC (Write Operation Complete) bit in the
163: * ASR (Adapter Status Register) is asserted.
164: */
165: static int
166: wait_WOC(sc, line)
167: struct cnw_softc *sc;
168: int line;
169: {
170: int i, asr;
171:
172: for (i = 0; i < 5000; i++) {
173: asr = bus_space_read_1(sc->sc_iot, sc->sc_ioh, CNW_REG_ASR);
174: if (asr & CNW_ASR_WOC)
175: return (0);
176: DELAY(100);
177: }
178: if (line > 0)
179: printf("%s: wedged at line %d\n", sc->sc_dev.dv_xname, line);
180: return (1);
181: }
182: #define WAIT_WOC(sc) wait_WOC(sc, __LINE__)
183:
184:
185: /*
186: * Read a 16 bit value from the card.
187: */
188: static int
189: read16(sc, offset)
190: struct cnw_softc *sc;
191: int offset;
192: {
193: int hi, lo;
194:
195: /* This could presumably be done more efficient with
196: * bus_space_read_2(), but I don't know anything about the
197: * byte sex guarantees... Besides, this is pretty cheap as
198: * well :-)
199: */
200: lo = bus_space_read_1(sc->sc_memt, sc->sc_memh,
201: sc->sc_memoff + offset);
202: hi = bus_space_read_1(sc->sc_memt, sc->sc_memh,
203: sc->sc_memoff + offset + 1);
204: return ((hi << 8) | lo);
205: }
206:
207:
208: /*
209: * Send a command to the card by writing it to the command buffer.
210: */
211: int
212: cnw_cmd(sc, cmd, count, arg1, arg2)
213: struct cnw_softc *sc;
214: int cmd, count, arg1, arg2;
215: {
216: int ptr = sc->sc_memoff + CNW_EREG_CB;
217:
218: if (wait_WOC(sc, 0)) {
219: printf("%s: wedged when issuing cmd 0x%x\n",
220: sc->sc_dev.dv_xname, cmd);
221: /*
222: * We'll continue anyway, as that's probably the best
223: * thing we can do; at least the user knows there's a
224: * problem, and can reset the interface with ifconfig
225: * down/up.
226: */
227: }
228:
229: bus_space_write_1(sc->sc_memt, sc->sc_memh, ptr, cmd);
230: if (count > 0) {
231: bus_space_write_1(sc->sc_memt, sc->sc_memh, ptr + 1, arg1);
232: if (count > 1)
233: bus_space_write_1(sc->sc_memt, sc->sc_memh,
234: ptr + 2, arg2);
235: }
236: bus_space_write_1(sc->sc_memt, sc->sc_memh,
237: ptr + count + 1, CNW_CMD_EOC);
238: return (0);
239: }
240: #define CNW_CMD0(sc, cmd) \
241: do { cnw_cmd(sc, cmd, 0, 0, 0); } while (0)
242: #define CNW_CMD1(sc, cmd, arg1) \
243: do { cnw_cmd(sc, cmd, 1, arg1 , 0); } while (0)
244: #define CNW_CMD2(sc, cmd, arg1, arg2) \
245: do { cnw_cmd(sc, cmd, 2, arg1, arg2); } while (0)
246:
247: /* ---------------------------------------------------------------- */
248:
249: /*
250: * Reset the hardware.
251: */
252: void
253: cnw_reset(sc)
254: struct cnw_softc *sc;
255: {
256: #ifdef CNW_DEBUG
257: if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG)
258: printf("%s: resetting\n", sc->sc_dev.dv_xname);
259: #endif
260: wait_WOC(sc, 0);
261: bus_space_write_1(sc->sc_iot, sc->sc_ioh, CNW_REG_PMR, CNW_PMR_RESET);
262: bus_space_write_1(sc->sc_memt, sc->sc_memh,
263: sc->sc_memoff + CNW_EREG_ASCC, CNW_ASR_WOC);
264: bus_space_write_1(sc->sc_iot, sc->sc_ioh, CNW_REG_PMR, 0);
265: }
266:
267:
268: /*
269: * Initialize the card.
270: */
271: void
272: cnw_init(sc)
273: struct cnw_softc *sc;
274: {
275: /* Reset the card */
276: cnw_reset(sc);
277:
278: /* Issue a NOP to check the card */
279: CNW_CMD0(sc, CNW_CMD_NOP);
280:
281: /* Set up receive configuration */
282: CNW_CMD1(sc, CNW_CMD_SRC, CNW_RXCONF_RXENA | CNW_RXCONF_BCAST);
283:
284: /* Set up transmit configuration */
285: CNW_CMD1(sc, CNW_CMD_STC, CNW_TXCONF_TXENA);
286:
287: /* Set domain */
288: CNW_CMD2(sc, CNW_CMD_SMD, sc->sc_domain, sc->sc_domain >> 8);
289:
290: /* Set scramble key */
291: CNW_CMD2(sc, CNW_CMD_SSK, sc->sc_skey, sc->sc_skey >> 8);
292:
293: /* Enable interrupts */
294: WAIT_WOC(sc);
295: bus_space_write_1(sc->sc_iot, sc->sc_ioh,
296: CNW_REG_IMR, CNW_IMR_IENA | CNW_IMR_RFU1);
297:
298: /* Enable receiver */
299: CNW_CMD0(sc, CNW_CMD_ER);
300:
301: /* "Set the IENA bit in COR" */
302: WAIT_WOC(sc);
303: bus_space_write_1(sc->sc_iot, sc->sc_ioh, CNW_REG_COR,
304: CNW_COR_IENA | CNW_COR_LVLREQ);
305: }
306:
307:
308: /*
309: * Enable and initialize the card.
310: */
311: int
312: cnw_enable(sc)
313: struct cnw_softc *sc;
314: {
315: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
316:
317: sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_NET,
318: cnw_intr, sc, sc->sc_dev.dv_xname);
319: if (sc->sc_ih == NULL) {
320: printf("%s: couldn't establish interrupt handler\n",
321: sc->sc_dev.dv_xname);
322: return (EIO);
323: }
324: if (pcmcia_function_enable(sc->sc_pf) != 0) {
325: printf("%s: couldn't enable card\n", sc->sc_dev.dv_xname);
326: return (EIO);
327: }
328: cnw_init(sc);
329: ifp->if_flags |= IFF_RUNNING;
330: return (0);
331: }
332:
333:
334: /*
335: * Stop and disable the card.
336: */
337: void
338: cnw_disable(sc)
339: struct cnw_softc *sc;
340: {
341: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
342:
343: pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
344: pcmcia_function_disable(sc->sc_pf);
345: ifp->if_flags &= ~IFF_RUNNING;
346: ifp->if_timer = 0;
347: }
348:
349:
350: /*
351: * Match the hardware we handle.
352: */
353: int
354: cnw_match(parent, match, aux)
355: struct device *parent;
356: void *match, *aux;
357: {
358: struct pcmcia_attach_args *pa = aux;
359:
360: if (pa->manufacturer == PCMCIA_VENDOR_XIRCOM &&
361: pa->product == PCMCIA_PRODUCT_XIRCOM_XIR_CNW_801)
362: return (1);
363: if (pa->manufacturer == PCMCIA_VENDOR_XIRCOM &&
364: pa->product == PCMCIA_PRODUCT_XIRCOM_XIR_CNW_802)
365: return (1);
366: return (0);
367: }
368:
369:
370: /*
371: * Attach the card.
372: */
373: void
374: cnw_attach(parent, self, aux)
375: struct device *parent, *self;
376: void *aux;
377: {
378: struct cnw_softc *sc = (void *) self;
379: struct pcmcia_attach_args *pa = aux;
380: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
381: int i;
382:
383: /* Enable the card */
384: sc->sc_pf = pa->pf;
385: pcmcia_function_init(sc->sc_pf, SIMPLEQ_FIRST(&sc->sc_pf->cfe_head));
386: if (pcmcia_function_enable(sc->sc_pf)) {
387: printf(": function enable failed\n");
388: return;
389: }
390:
391: /* Map I/O register and "memory" */
392: if (pcmcia_io_alloc(sc->sc_pf, 0, CNW_IO_SIZE, CNW_IO_SIZE,
393: &sc->sc_pcioh) != 0) {
394: printf(": can't allocate i/o space\n");
395: return;
396: }
397: if (pcmcia_io_map(sc->sc_pf, PCMCIA_WIDTH_IO16, 0,
398: CNW_IO_SIZE, &sc->sc_pcioh, &sc->sc_iowin) != 0) {
399: printf(": can't map i/o space\n");
400: return;
401: }
402: sc->sc_iot = sc->sc_pcioh.iot;
403: sc->sc_ioh = sc->sc_pcioh.ioh;
404: if (pcmcia_mem_alloc(sc->sc_pf, CNW_MEM_SIZE, &sc->sc_pcmemh) != 0) {
405: printf(": can't allocate memory\n");
406: return;
407: }
408: if (pcmcia_mem_map(sc->sc_pf, PCMCIA_MEM_COMMON, CNW_MEM_ADDR,
409: CNW_MEM_SIZE, &sc->sc_pcmemh, &sc->sc_memoff,
410: &sc->sc_memwin) != 0) {
411: printf(": can't map memory\n");
412: return;
413: }
414: sc->sc_memt = sc->sc_pcmemh.memt;
415: sc->sc_memh = sc->sc_pcmemh.memh;
416:
417: /* Finish setup of softc */
418: sc->sc_domain = cnw_domain;
419: sc->sc_skey = cnw_skey;
420:
421: /* Get MAC address */
422: cnw_reset(sc);
423: for (i = 0; i < ETHER_ADDR_LEN; i++)
424: sc->sc_arpcom.ac_enaddr[i] = bus_space_read_1(sc->sc_memt,
425: sc->sc_memh, sc->sc_memoff + CNW_EREG_PA + i);
426: printf("%s: address %s\n", sc->sc_dev.dv_xname,
427: ether_sprintf(sc->sc_arpcom.ac_enaddr));
428:
429: /* Set up ifnet structure */
430: bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
431: ifp->if_softc = sc;
432: ifp->if_start = cnw_start;
433: ifp->if_ioctl = cnw_ioctl;
434: ifp->if_watchdog = cnw_watchdog;
435: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS;
436: IFQ_SET_READY(&ifp->if_snd);
437:
438: /* Attach the interface */
439: if_attach(ifp);
440: ether_ifattach(ifp);
441:
442: /* Disable the card now, and turn it on when the interface goes up */
443: pcmcia_function_disable(sc->sc_pf);
444: }
445:
446: /*
447: * Start outputting on the interface.
448: */
449: void
450: cnw_start(ifp)
451: struct ifnet *ifp;
452: {
453: struct cnw_softc *sc = ifp->if_softc;
454: struct mbuf *m0;
455: int asr;
456:
457: #ifdef CNW_DEBUG
458: if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG)
459: printf("%s: cnw_start\n", ifp->if_xname);
460: #endif
461:
462: for (;;) {
463: /* Is there any buffer space available on the card? */
464: WAIT_WOC(sc);
465: asr = bus_space_read_1(sc->sc_iot, sc->sc_ioh, CNW_REG_ASR);
466: if (!(asr & CNW_ASR_TXBA)) {
467: #ifdef CNW_DEBUG
468: if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG)
469: printf("%s: no buffer space\n", ifp->if_xname);
470: #endif
471: return;
472: }
473:
474: IFQ_DEQUEUE(&ifp->if_snd, m0);
475: if (m0 == 0)
476: return;
477:
478: #if NBPFILTER > 0
479: if (ifp->if_bpf)
480: bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
481: #endif
482:
483: cnw_transmit(sc, m0);
484: ++ifp->if_opackets;
485: ifp->if_timer = 3; /* start watchdog timer */
486: }
487: }
488:
489:
490: /*
491: * Transmit a packet.
492: */
493: void
494: cnw_transmit(sc, m0)
495: struct cnw_softc *sc;
496: struct mbuf *m0;
497: {
498: int buffer, bufsize, bufoffset, bufptr, bufspace, len, mbytes, n;
499: struct mbuf *m;
500: u_int8_t *mptr;
501:
502: /* Get buffer info from card */
503: buffer = read16(sc, CNW_EREG_TDP);
504: bufsize = read16(sc, CNW_EREG_TDP + 2);
505: bufoffset = read16(sc, CNW_EREG_TDP + 4);
506: #ifdef CNW_DEBUG
507: if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG)
508: printf("%s: cnw_transmit b=0x%x s=%d o=0x%x\n",
509: sc->sc_dev.dv_xname, buffer, bufsize, bufoffset);
510: #endif
511:
512: /* Copy data from mbuf chain to card buffers */
513: bufptr = sc->sc_memoff + buffer + bufoffset;
514: bufspace = bufsize;
515: len = 0;
516: for (m = m0; m; ) {
517: mptr = mtod(m, u_int8_t *);
518: mbytes = m->m_len;
519: len += mbytes;
520: while (mbytes > 0) {
521: if (bufspace == 0) {
522: buffer = read16(sc, buffer);
523: bufptr = sc->sc_memoff + buffer + bufoffset;
524: bufspace = bufsize;
525: #ifdef CNW_DEBUG
526: if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG)
527: printf("%s: next buffer @0x%x\n",
528: sc->sc_dev.dv_xname, buffer);
529: #endif
530: }
531: n = mbytes <= bufspace ? mbytes : bufspace;
532: bus_space_write_region_1(sc->sc_memt, sc->sc_memh,
533: bufptr, mptr, n);
534: bufptr += n;
535: bufspace -= n;
536: mptr += n;
537: mbytes -= n;
538: }
539: MFREE(m, m0);
540: m = m0;
541: }
542:
543: /* Issue transmit command */
544: CNW_CMD2(sc, CNW_CMD_TL, len, len >> 8);
545: }
546:
547:
548: /*
549: * Pull a packet from the card into an mbuf chain.
550: */
551: struct mbuf *
552: cnw_read(sc)
553: struct cnw_softc *sc;
554: {
555: struct mbuf *m, *top, **mp;
556: int totbytes, buffer, bufbytes, bufptr, mbytes, n;
557: u_int8_t *mptr;
558:
559: WAIT_WOC(sc);
560: totbytes = read16(sc, CNW_EREG_RDP);
561: #ifdef CNW_DEBUG
562: if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG)
563: printf("%s: recv %d bytes\n", sc->sc_dev.dv_xname, totbytes);
564: #endif
565: buffer = CNW_EREG_RDP + 2;
566: bufbytes = 0;
567: bufptr = 0; /* XXX make gcc happy */
568:
569: MGETHDR(m, M_DONTWAIT, MT_DATA);
570: if (m == 0)
571: return (0);
572: m->m_pkthdr.rcvif = &sc->sc_arpcom.ac_if;
573: m->m_pkthdr.len = totbytes;
574: mbytes = MHLEN;
575: top = 0;
576: mp = ⊤
577:
578: while (totbytes > 0) {
579: if (top) {
580: MGET(m, M_DONTWAIT, MT_DATA);
581: if (m == 0) {
582: m_freem(top);
583: return (0);
584: }
585: mbytes = MLEN;
586: }
587: if (totbytes >= MINCLSIZE) {
588: MCLGET(m, M_DONTWAIT);
589: if ((m->m_flags & M_EXT) == 0) {
590: m_free(m);
591: m_freem(top);
592: return (0);
593: }
594: mbytes = MCLBYTES;
595: }
596: if (!top) {
597: int pad =
598: ALIGN(sizeof(struct ether_header)) -
599: sizeof(struct ether_header);
600: m->m_data += pad;
601: mbytes -= pad;
602: }
603: mptr = mtod(m, u_int8_t *);
604: mbytes = m->m_len = min(totbytes, mbytes);
605: totbytes -= mbytes;
606: while (mbytes > 0) {
607: if (bufbytes == 0) {
608: buffer = read16(sc, buffer);
609: bufbytes = read16(sc, buffer + 2);
610: bufptr = sc->sc_memoff + buffer +
611: read16(sc, buffer + 4);
612: #ifdef CNW_DEBUG
613: if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG)
614: printf("%s: %d bytes @0x%x+0x%x\n",
615: sc->sc_dev.dv_xname, bufbytes,
616: buffer, bufptr - buffer -
617: sc->sc_memoff);
618: #endif
619: }
620: n = mbytes <= bufbytes ? mbytes : bufbytes;
621: bus_space_read_region_1(sc->sc_memt, sc->sc_memh,
622: bufptr, mptr, n);
623: bufbytes -= n;
624: bufptr += n;
625: mbytes -= n;
626: mptr += n;
627: }
628: *mp = m;
629: mp = &m->m_next;
630: }
631:
632: return (top);
633: }
634:
635:
636: /*
637: * Handle received packets.
638: */
639: void
640: cnw_recv(sc)
641: struct cnw_softc *sc;
642: {
643: int rser;
644: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
645: struct mbuf *m;
646: struct ether_header *eh;
647:
648: for (;;) {
649: WAIT_WOC(sc);
650: rser = bus_space_read_1(sc->sc_memt, sc->sc_memh,
651: sc->sc_memoff + CNW_EREG_RSER);
652: if (!(rser & CNW_RSER_RXAVAIL))
653: return;
654:
655: /* Pull packet off card */
656: m = cnw_read(sc);
657:
658: /* Acknowledge packet */
659: CNW_CMD0(sc, CNW_CMD_SRP);
660:
661: /* Did we manage to get the packet from the interface? */
662: if (m == 0) {
663: ++ifp->if_ierrors;
664: return;
665: }
666: ++ifp->if_ipackets;
667:
668: #if NBPFILTER > 0
669: if (ifp->if_bpf)
670: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
671: #endif
672:
673: /*
674: * Check that the packet is for us or {multi,broad}cast. Maybe
675: * there's a fool-poof hardware check for this, but I don't
676: * really know...
677: */
678: eh = mtod(m, struct ether_header *);
679: if ((eh->ether_dhost[0] & 1) == 0 && /* !mcast and !bcast */
680: bcmp(sc->sc_arpcom.ac_enaddr, eh->ether_dhost,
681: sizeof(eh->ether_dhost)) != 0) {
682: m_freem(m);
683: continue;
684: }
685:
686: ether_input_mbuf(ifp, m);
687: }
688: }
689:
690:
691: /*
692: * Interrupt handler.
693: */
694: int
695: cnw_intr(arg)
696: void *arg;
697: {
698: struct cnw_softc *sc = arg;
699: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
700: int ret, status, rser, tser;
701:
702: if (!(sc->sc_arpcom.ac_if.if_flags & IFF_RUNNING))
703: return (0);
704: ifp->if_timer = 0; /* stop watchdog timer */
705:
706: ret = 0;
707: for (;;) {
708: WAIT_WOC(sc);
709: if (!(bus_space_read_1(sc->sc_iot, sc->sc_ioh,
710: CNW_REG_CCSR) & 0x02)) {
711: if (ret == 0)
712: printf("%s: spurious interrupt\n",
713: sc->sc_dev.dv_xname);
714: return (ret);
715: }
716: ret = 1;
717: status = bus_space_read_1(sc->sc_iot, sc->sc_ioh, CNW_REG_ASR);
718:
719: /* Anything to receive? */
720: if (status & CNW_ASR_RXRDY)
721: cnw_recv(sc);
722:
723: /* Receive error */
724: if (status & CNW_ASR_RXERR) {
725: /*
726: * I get a *lot* of spurious receive errors
727: * (many per second), even when the interface
728: * is quiescent, so we don't increment
729: * if_ierrors here.
730: */
731: rser = bus_space_read_1(sc->sc_memt, sc->sc_memh,
732: sc->sc_memoff + CNW_EREG_RSER);
733: /* Clear error bits in RSER */
734: WAIT_WOC(sc);
735: bus_space_write_1(sc->sc_memt, sc->sc_memh,
736: sc->sc_memoff + CNW_EREG_RSERW,
737: CNW_RSER_RXERR |
738: (rser & (CNW_RSER_RXCRC | CNW_RSER_RXBIG)));
739: /* Clear RXERR in ASR */
740: WAIT_WOC(sc);
741: bus_space_write_1(sc->sc_memt, sc->sc_memh,
742: sc->sc_memoff + CNW_EREG_ASCC, CNW_ASR_RXERR);
743: }
744:
745: /* Transmit done */
746: if (status & CNW_ASR_TXDN) {
747: tser = bus_space_read_1(sc->sc_memt, sc->sc_memh,
748: CNW_EREG_TSER);
749: if (tser & CNW_TSER_TXOK) {
750: WAIT_WOC(sc);
751: bus_space_write_1(sc->sc_memt, sc->sc_memh,
752: sc->sc_memoff + CNW_EREG_TSERW,
753: CNW_TSER_TXOK | CNW_TSER_RTRY);
754: }
755: if (tser & CNW_TSER_ERROR) {
756: ++ifp->if_oerrors;
757: WAIT_WOC(sc);
758: bus_space_write_1(sc->sc_memt, sc->sc_memh,
759: sc->sc_memoff + CNW_EREG_TSERW,
760: (tser & CNW_TSER_ERROR) |
761: CNW_TSER_RTRY);
762: }
763: /* Continue to send packets from the queue */
764: cnw_start(&sc->sc_arpcom.ac_if);
765: }
766:
767: }
768: }
769:
770:
771: /*
772: * Handle device ioctls.
773: */
774: int
775: cnw_ioctl(ifp, cmd, data)
776: register struct ifnet *ifp;
777: u_long cmd;
778: caddr_t data;
779: {
780: struct cnw_softc *sc = ifp->if_softc;
781: struct ifaddr *ifa = (struct ifaddr *)data;
782: int s, error = 0;
783:
784: s = splnet();
785:
786: switch (cmd) {
787:
788: case SIOCSIFADDR:
789: if (!(ifp->if_flags & IFF_RUNNING) &&
790: (error = cnw_enable(sc)) != 0)
791: break;
792: ifp->if_flags |= IFF_UP;
793: switch (ifa->ifa_addr->sa_family) {
794: #ifdef INET
795: case AF_INET:
796: arp_ifinit(&sc->sc_arpcom, ifa);
797: break;
798: #endif
799: }
800: break;
801:
802: case SIOCSIFFLAGS:
803: if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == IFF_RUNNING) {
804: /*
805: * The interface is marked down and it is running, so
806: * stop it.
807: */
808: cnw_disable(sc);
809: } else if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == IFF_UP){
810: /*
811: * The interface is marked up and it is stopped, so
812: * start it.
813: */
814: error = cnw_enable(sc);
815: }
816: break;
817:
818: default:
819: error = EINVAL;
820: break;
821: }
822:
823: splx(s);
824: return (error);
825: }
826:
827:
828: /*
829: * Device timeout/watchdog routine. Entered if the device neglects to
830: * generate an interrupt after a transmit has been started on it.
831: */
832: void
833: cnw_watchdog(ifp)
834: struct ifnet *ifp;
835: {
836: struct cnw_softc *sc = ifp->if_softc;
837:
838: printf("%s: device timeout; card reset\n", sc->sc_dev.dv_xname);
839: ++ifp->if_oerrors;
840: cnw_init(sc);
841: }
842:
843:
844: int
845: cnw_detach(dev, flags)
846: struct device *dev;
847: int flags;
848: {
849: struct cnw_softc *sc = (struct cnw_softc *)dev;
850: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
851: int rv = 0;
852:
853: pcmcia_io_unmap(sc->sc_pf, sc->sc_iowin);
854: pcmcia_io_free(sc->sc_pf, &sc->sc_pcioh);
855: pcmcia_mem_unmap(sc->sc_pf, sc->sc_memwin);
856: pcmcia_mem_free(sc->sc_pf, &sc->sc_pcmemh);
857:
858: ether_ifdetach(ifp);
859: if_detach(ifp);
860:
861: return (rv);
862: }
863:
864: int
865: cnw_activate(dev, act)
866: struct device *dev;
867: enum devact act;
868: {
869: struct cnw_softc *sc = (struct cnw_softc *)dev;
870: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
871: int s;
872:
873: s = splnet();
874: switch (act) {
875: case DVACT_ACTIVATE:
876: pcmcia_function_enable(sc->sc_pf);
877: sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_NET,
878: cnw_intr, sc, sc->sc_dev.dv_xname);
879: cnw_init(sc);
880: break;
881:
882: case DVACT_DEACTIVATE:
883: ifp->if_timer = 0;
884: ifp->if_flags &= ~IFF_RUNNING; /* XXX no cnw_stop() ? */
885: pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
886: pcmcia_function_disable(sc->sc_pf);
887: break;
888: }
889: splx(s);
890: return (0);
891: }