6970d93bc35f18fcdaf1a5dd8f62ed1b597a0a43
[dragonfly.git] / sys / dev / netif / sn / if_sn.c
1 /*
2  * Copyright (c) 1996 Gardner Buchanan <gbuchanan@shl.com>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by Gardner Buchanan.
16  * 4. The name of Gardner Buchanan may not be used to endorse or promote
17  *    products derived from this software without specific prior written
18  *    permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  *
31  *   $FreeBSD: src/sys/dev/sn/if_sn.c,v 1.7.2.3 2001/02/04 04:38:38 toshi Exp $
32  *   $DragonFly: src/sys/dev/netif/sn/if_sn.c,v 1.20 2005/06/16 14:51:55 joerg Exp $
33  */
34
35 /*
36  * This is a driver for SMC's 9000 series of Ethernet adapters.
37  *
38  * This FreeBSD driver is derived from the smc9194 Linux driver by
39  * Erik Stahlman and is Copyright (C) 1996 by Erik Stahlman.
40  * This driver also shamelessly borrows from the FreeBSD ep driver
41  * which is Copyright (C) 1994 Herb Peyerl <hpeyerl@novatel.ca>
42  * All rights reserved.
43  *
44  * It is set up for my SMC91C92 equipped Ampro LittleBoard embedded
45  * PC.  It is adapted from Erik Stahlman's Linux driver which worked
46  * with his EFA Info*Express SVC VLB adaptor.  According to SMC's databook,
47  * it will work for the entire SMC 9xxx series. (Ha Ha)
48  *
49  * "Features" of the SMC chip:
50  *   4608 byte packet memory. (for the 91C92.  Others have more)
51  *   EEPROM for configuration
52  *   AUI/TP selection
53  *
54  * Authors:
55  *      Erik Stahlman                   erik@vt.edu
56  *      Herb Peyerl                     hpeyerl@novatel.ca
57  *      Andres Vega Garcia              avega@sophia.inria.fr
58  *      Serge Babkin                    babkin@hq.icb.chel.su
59  *      Gardner Buchanan                gbuchanan@shl.com
60  *
61  * Sources:
62  *    o   SMC databook
63  *    o   "smc9194.c:v0.10(FIXED) 02/15/96 by Erik Stahlman (erik@vt.edu)"
64  *    o   "if_ep.c,v 1.19 1995/01/24 20:53:45 davidg Exp"
65  *
66  * Known Bugs:
67  *    o   The hardware multicast filter isn't used yet.
68  *    o   Setting of the hardware address isn't supported.
69  *    o   Hardware padding isn't used.
70  */
71
72 /*
73  * Modifications for Megahertz X-Jack Ethernet Card (XJ-10BT)
74  * 
75  * Copyright (c) 1996 by Tatsumi Hosokawa <hosokawa@jp.FreeBSD.org>
76  *                       BSD-nomads, Tokyo, Japan.
77  */
78 /*
79  * Multicast support by Kei TANAKA <kei@pal.xerox.com>
80  * Special thanks to itojun@itojun.org
81  */
82
83 #undef  SN_DEBUG        /* (by hosokawa) */
84
85 #include <sys/param.h>
86 #include <sys/systm.h>
87 #include <sys/kernel.h>
88 #include <sys/errno.h>
89 #include <sys/sockio.h>
90 #include <sys/malloc.h>
91 #include <sys/mbuf.h>
92 #include <sys/socket.h>
93 #include <sys/syslog.h>
94 #include <sys/thread2.h>
95
96 #include <sys/module.h>
97 #include <sys/bus.h>
98
99 #include <machine/bus.h>
100 #include <machine/resource.h>
101 #include <sys/rman.h> 
102
103 #include <net/ethernet.h>
104 #include <net/if.h>
105 #include <net/ifq_var.h>
106 #include <net/if_arp.h>
107 #include <net/if_dl.h>
108 #include <net/if_types.h>
109 #include <net/if_mib.h>
110
111 #ifdef INET
112 #include <netinet/in.h>
113 #include <netinet/in_systm.h>
114 #include <netinet/in_var.h>
115 #include <netinet/ip.h>
116 #endif
117
118 #ifdef NS
119 #include <netns/ns.h>
120 #include <netns/ns_if.h>
121 #endif
122
123 #include <net/bpf.h>
124 #include <net/bpfdesc.h>
125
126 #include <machine/clock.h>
127
128 #include "if_snreg.h"
129 #include "if_snvar.h"
130
131 /* Exported variables */
132 devclass_t sn_devclass;
133
134 static int snioctl(struct ifnet * ifp, u_long, caddr_t, struct ucred *);
135
136 static void snresume(struct ifnet *);
137
138 void sninit(void *);
139 void snread(struct ifnet *);
140 void snreset(struct sn_softc *);
141 void snstart(struct ifnet *);
142 void snstop(struct sn_softc *);
143 void snwatchdog(struct ifnet *);
144
145 static void sn_setmcast(struct sn_softc *);
146 static int sn_getmcf(struct arpcom *ac, u_char *mcf);
147 static u_int smc_crc(u_char *);
148
149 DECLARE_DUMMY_MODULE(if_sn);
150
151 /* I (GB) have been unlucky getting the hardware padding
152  * to work properly.
153  */
154 #define SW_PAD
155
156 static const char *chip_ids[15] = {
157         NULL, NULL, NULL,
158          /* 3 */ "SMC91C90/91C92",
159          /* 4 */ "SMC91C94",
160          /* 5 */ "SMC91C95",
161         NULL,
162          /* 7 */ "SMC91C100",
163          /* 8 */ "SMC91C100FD",
164         NULL, NULL, NULL,
165         NULL, NULL, NULL
166 };
167
168 int
169 sn_attach(device_t dev)
170 {
171         struct sn_softc *sc = device_get_softc(dev);
172         struct ifnet   *ifp = &sc->arpcom.ac_if;
173         u_short         i;
174         u_char         *p;
175         int             rev;
176         u_short         address;
177         int             j;
178
179         sn_activate(dev);
180
181         snstop(sc);
182
183         sc->dev = dev;
184         sc->pages_wanted = -1;
185
186         device_printf(dev, " ");
187
188         SMC_SELECT_BANK(3);
189         rev = inw(BASE + REVISION_REG_W);
190         if (chip_ids[(rev >> 4) & 0xF])
191                 printf("%s ", chip_ids[(rev >> 4) & 0xF]);
192
193         SMC_SELECT_BANK(1);
194         i = inw(BASE + CONFIG_REG_W);
195         printf("%s\n", i & CR_AUI_SELECT ? "AUI" : "UTP");
196
197         if (sc->pccard_enaddr)
198                 for (j = 0; j < 3; j++) {
199                         u_short w;
200
201                         w = (u_short)sc->arpcom.ac_enaddr[j * 2] | 
202                                 (((u_short)sc->arpcom.ac_enaddr[j * 2 + 1]) << 8);
203                         outw(BASE + IAR_ADDR0_REG_W + j * 2, w);
204                 }
205
206         /*
207          * Read the station address from the chip. The MAC address is bank 1,
208          * regs 4 - 9
209          */
210         SMC_SELECT_BANK(1);
211         p = (u_char *) & sc->arpcom.ac_enaddr;
212         for (i = 0; i < 6; i += 2) {
213                 address = inw(BASE + IAR_ADDR0_REG_W + i);
214                 p[i + 1] = address >> 8;
215                 p[i] = address & 0xFF;
216         }
217         ifp->if_softc = sc;
218         if_initname(ifp, "sn", device_get_unit(dev));
219         ifp->if_mtu = ETHERMTU;
220         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
221         ifp->if_start = snstart;
222         ifp->if_ioctl = snioctl;
223         ifp->if_watchdog = snwatchdog;
224         ifp->if_init = sninit;
225         ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
226         ifq_set_ready(&ifp->if_snd);
227         ifp->if_timer = 0;
228
229         ether_ifattach(ifp, sc->arpcom.ac_enaddr);
230
231         return 0;
232 }
233
234
235 /*
236  * Reset and initialize the chip
237  */
238 void
239 sninit(void *xsc)
240 {
241         struct sn_softc *sc = xsc;
242         struct ifnet *ifp = &sc->arpcom.ac_if;
243         int             flags;
244         int             mask;
245
246         crit_enter();
247
248         /*
249          * This resets the registers mostly to defaults, but doesn't affect
250          * EEPROM.  After the reset cycle, we pause briefly for the chip to
251          * be happy.
252          */
253         SMC_SELECT_BANK(0);
254         outw(BASE + RECV_CONTROL_REG_W, RCR_SOFTRESET);
255         SMC_DELAY();
256         outw(BASE + RECV_CONTROL_REG_W, 0x0000);
257         SMC_DELAY();
258         SMC_DELAY();
259
260         outw(BASE + TXMIT_CONTROL_REG_W, 0x0000);
261
262         /*
263          * Set the control register to automatically release succesfully
264          * transmitted packets (making the best use out of our limited
265          * memory) and to enable the EPH interrupt on certain TX errors.
266          */
267         SMC_SELECT_BANK(1);
268         outw(BASE + CONTROL_REG_W, (CTR_AUTO_RELEASE | CTR_TE_ENABLE |
269                                     CTR_CR_ENABLE | CTR_LE_ENABLE));
270
271         /* Set squelch level to 240mV (default 480mV) */
272         flags = inw(BASE + CONFIG_REG_W);
273         flags |= CR_SET_SQLCH;
274         outw(BASE + CONFIG_REG_W, flags);
275
276         /*
277          * Reset the MMU and wait for it to be un-busy.
278          */
279         SMC_SELECT_BANK(2);
280         outw(BASE + MMU_CMD_REG_W, MMUCR_RESET);
281         while (inw(BASE + MMU_CMD_REG_W) & MMUCR_BUSY)  /* NOTHING */
282                 ;
283
284         /*
285          * Disable all interrupts
286          */
287         outb(BASE + INTR_MASK_REG_B, 0x00);
288
289         sn_setmcast(sc);
290
291         /*
292          * Set the transmitter control.  We want it enabled.
293          */
294         flags = TCR_ENABLE;
295
296 #ifndef SW_PAD
297         /*
298          * I (GB) have been unlucky getting this to work.
299          */
300         flags |= TCR_PAD_ENABLE;
301 #endif  /* SW_PAD */
302
303         outw(BASE + TXMIT_CONTROL_REG_W, flags);
304
305
306         /*
307          * Now, enable interrupts
308          */
309         SMC_SELECT_BANK(2);
310
311         mask = IM_EPH_INT |
312                 IM_RX_OVRN_INT |
313                 IM_RCV_INT |
314                 IM_TX_INT;
315
316         outb(BASE + INTR_MASK_REG_B, mask);
317         sc->intr_mask = mask;
318         sc->pages_wanted = -1;
319
320
321         /*
322          * Mark the interface running but not active.
323          */
324         ifp->if_flags |= IFF_RUNNING;
325         ifp->if_flags &= ~IFF_OACTIVE;
326
327         /*
328          * Attempt to push out any waiting packets.
329          */
330         snstart(ifp);
331
332         crit_exit();
333 }
334
335
336 void
337 snstart(struct ifnet *ifp)
338 {
339         struct sn_softc *sc = ifp->if_softc;
340         u_int  len;
341         struct mbuf *m;
342         struct mbuf    *top;
343         int             pad;
344         int             mask;
345         u_short         length;
346         u_short         numPages;
347         u_char          packet_no;
348         int             time_out;
349
350         crit_enter();
351
352         if (ifp->if_flags & IFF_OACTIVE) {
353                 crit_exit();
354                 return;
355         }
356         if (sc->pages_wanted != -1) {
357                 crit_exit();
358                 printf("%s: snstart() while memory allocation pending\n",
359                        ifp->if_xname);
360                 return;
361         }
362 startagain:
363
364         /*
365          * Sneak a peek at the next packet
366          */
367         m = ifq_poll(&ifp->if_snd);
368         if (m == 0) {
369                 crit_exit();
370                 return;
371         }
372         /*
373          * Compute the frame length and set pad to give an overall even
374          * number of bytes.  Below we assume that the packet length is even.
375          */
376         for (len = 0, top = m; m; m = m->m_next)
377                 len += m->m_len;
378
379         pad = (len & 1);
380
381         /*
382          * We drop packets that are too large. Perhaps we should truncate
383          * them instead?
384          */
385         if (len + pad > ETHER_MAX_LEN - ETHER_CRC_LEN) {
386                 printf("%s: large packet discarded (A)\n", ifp->if_xname);
387                 ++sc->arpcom.ac_if.if_oerrors;
388                 m = ifq_dequeue(&ifp->if_snd);
389                 m_freem(m);
390                 goto readcheck;
391         }
392 #ifdef SW_PAD
393
394         /*
395          * If HW padding is not turned on, then pad to ETHER_MIN_LEN.
396          */
397         if (len < ETHER_MIN_LEN - ETHER_CRC_LEN)
398                 pad = ETHER_MIN_LEN - ETHER_CRC_LEN - len;
399
400 #endif  /* SW_PAD */
401
402         length = pad + len;
403
404         /*
405          * The MMU wants the number of pages to be the number of 256 byte
406          * 'pages', minus 1 (A packet can't ever have 0 pages. We also
407          * include space for the status word, byte count and control bytes in
408          * the allocation request.
409          */
410         numPages = (length + 6) >> 8;
411
412
413         /*
414          * Now, try to allocate the memory
415          */
416         SMC_SELECT_BANK(2);
417         outw(BASE + MMU_CMD_REG_W, MMUCR_ALLOC | numPages);
418
419         /*
420          * Wait a short amount of time to see if the allocation request
421          * completes.  Otherwise, I enable the interrupt and wait for
422          * completion asyncronously.
423          */
424
425         time_out = MEMORY_WAIT_TIME;
426         do {
427                 if (inb(BASE + INTR_STAT_REG_B) & IM_ALLOC_INT)
428                         break;
429         } while (--time_out);
430
431         if (!time_out) {
432
433                 /*
434                  * No memory now.  Oh well, wait until the chip finds memory
435                  * later.   Remember how many pages we were asking for and
436                  * enable the allocation completion interrupt. Also set a
437                  * watchdog in case  we miss the interrupt. We mark the
438                  * interface active since there is no point in attempting an
439                  * snstart() until after the memory is available.
440                  */
441                 mask = inb(BASE + INTR_MASK_REG_B) | IM_ALLOC_INT;
442                 outb(BASE + INTR_MASK_REG_B, mask);
443                 sc->intr_mask = mask;
444
445                 ifp->if_timer = 1;
446                 ifp->if_flags |= IFF_OACTIVE;
447                 sc->pages_wanted = numPages;
448
449                 crit_exit();
450                 return;
451         }
452         /*
453          * The memory allocation completed.  Check the results.
454          */
455         packet_no = inb(BASE + ALLOC_RESULT_REG_B);
456         if (packet_no & ARR_FAILED) {
457                 printf("%s: Memory allocation failed\n", ifp->if_xname);
458                 goto startagain;
459         }
460         /*
461          * We have a packet number, so tell the card to use it.
462          */
463         outb(BASE + PACKET_NUM_REG_B, packet_no);
464
465         /*
466          * Point to the beginning of the packet
467          */
468         outw(BASE + POINTER_REG_W, PTR_AUTOINC | 0x0000);
469
470         /*
471          * Send the packet length (+6 for status, length and control byte)
472          * and the status word (set to zeros)
473          */
474         outw(BASE + DATA_REG_W, 0);
475         outb(BASE + DATA_REG_B, (length + 6) & 0xFF);
476         outb(BASE + DATA_REG_B, (length + 6) >> 8);
477
478         /*
479          * Get the packet from the kernel.  This will include the Ethernet
480          * frame header, MAC Addresses etc.
481          */
482         m = ifq_dequeue(&ifp->if_snd);
483
484         /*
485          * Push out the data to the card.
486          */
487         for (top = m; m != 0; m = m->m_next) {
488
489                 /*
490                  * Push out words.
491                  */
492                 outsw(BASE + DATA_REG_W, mtod(m, caddr_t), m->m_len / 2);
493
494                 /*
495                  * Push out remaining byte.
496                  */
497                 if (m->m_len & 1)
498                         outb(BASE + DATA_REG_B, *(mtod(m, caddr_t) + m->m_len - 1));
499         }
500
501         /*
502          * Push out padding.
503          */
504         while (pad > 1) {
505                 outw(BASE + DATA_REG_W, 0);
506                 pad -= 2;
507         }
508         if (pad)
509                 outb(BASE + DATA_REG_B, 0);
510
511         /*
512          * Push out control byte and unused packet byte The control byte is 0
513          * meaning the packet is even lengthed and no special CRC handling is
514          * desired.
515          */
516         outw(BASE + DATA_REG_W, 0);
517
518         /*
519          * Enable the interrupts and let the chipset deal with it Also set a
520          * watchdog in case we miss the interrupt.
521          */
522         mask = inb(BASE + INTR_MASK_REG_B) | (IM_TX_INT | IM_TX_EMPTY_INT);
523         outb(BASE + INTR_MASK_REG_B, mask);
524         sc->intr_mask = mask;
525
526         outw(BASE + MMU_CMD_REG_W, MMUCR_ENQUEUE);
527
528         ifp->if_flags |= IFF_OACTIVE;
529         ifp->if_timer = 1;
530
531         BPF_MTAP(ifp, top);
532
533         ifp->if_opackets++;
534         m_freem(top);
535
536 readcheck:
537
538         /*
539          * Is another packet coming in?  We don't want to overflow the tiny
540          * RX FIFO.  If nothing has arrived then attempt to queue another
541          * transmit packet.
542          */
543         if (inw(BASE + FIFO_PORTS_REG_W) & FIFO_REMPTY)
544                 goto startagain;
545
546         crit_exit();
547 }
548
549
550
551 /* Resume a packet transmit operation after a memory allocation
552  * has completed.
553  *
554  * This is basically a hacked up copy of snstart() which handles
555  * a completed memory allocation the same way snstart() does.
556  * It then passes control to snstart to handle any other queued
557  * packets.
558  */
559 static void
560 snresume(struct ifnet *ifp)
561 {
562         struct sn_softc *sc = ifp->if_softc;
563         u_int  len;
564         struct mbuf *m;
565         struct mbuf    *top;
566         int             pad;
567         int             mask;
568         u_short         length;
569         u_short         numPages;
570         u_short         pages_wanted;
571         u_char          packet_no;
572
573         if (sc->pages_wanted < 0)
574                 return;
575
576         pages_wanted = sc->pages_wanted;
577         sc->pages_wanted = -1;
578
579         /*
580          * Sneak a peek at the next packet
581          */
582         m = ifq_poll(&ifp->if_snd);
583         if (m == 0) {
584                 printf("%s: snresume() with nothing to send\n", ifp->if_xname);
585                 return;
586         }
587         /*
588          * Compute the frame length and set pad to give an overall even
589          * number of bytes.  Below we assume that the packet length is even.
590          */
591         for (len = 0, top = m; m; m = m->m_next)
592                 len += m->m_len;
593
594         pad = (len & 1);
595
596         /*
597          * We drop packets that are too large. Perhaps we should truncate
598          * them instead?
599          */
600         if (len + pad > ETHER_MAX_LEN - ETHER_CRC_LEN) {
601                 printf("%s: large packet discarded (B)\n", ifp->if_xname);
602                 ++ifp->if_oerrors;
603                 ifq_dequeue(&ifp->if_snd);
604                 m_freem(m);
605                 return;
606         }
607 #ifdef SW_PAD
608
609         /*
610          * If HW padding is not turned on, then pad to ETHER_MIN_LEN.
611          */
612         if (len < ETHER_MIN_LEN - ETHER_CRC_LEN)
613                 pad = ETHER_MIN_LEN - ETHER_CRC_LEN - len;
614
615 #endif  /* SW_PAD */
616
617         length = pad + len;
618
619
620         /*
621          * The MMU wants the number of pages to be the number of 256 byte
622          * 'pages', minus 1 (A packet can't ever have 0 pages. We also
623          * include space for the status word, byte count and control bytes in
624          * the allocation request.
625          */
626         numPages = (length + 6) >> 8;
627
628
629         SMC_SELECT_BANK(2);
630
631         /*
632          * The memory allocation completed.  Check the results. If it failed,
633          * we simply set a watchdog timer and hope for the best.
634          */
635         packet_no = inb(BASE + ALLOC_RESULT_REG_B);
636         if (packet_no & ARR_FAILED) {
637                 printf("%s: Memory allocation failed.  Weird.\n", ifp->if_xname);
638                 ifp->if_timer = 1;
639                 goto try_start;
640         }
641         /*
642          * We have a packet number, so tell the card to use it.
643          */
644         outb(BASE + PACKET_NUM_REG_B, packet_no);
645
646         /*
647          * Now, numPages should match the pages_wanted recorded when the
648          * memory allocation was initiated.
649          */
650         if (pages_wanted != numPages) {
651                 printf("%s: memory allocation wrong size.  Weird.\n", ifp->if_xname);
652                 /*
653                  * If the allocation was the wrong size we simply release the
654                  * memory once it is granted. Wait for the MMU to be un-busy.
655                  */
656                 while (inw(BASE + MMU_CMD_REG_W) & MMUCR_BUSY)  /* NOTHING */
657                         ;
658                 outw(BASE + MMU_CMD_REG_W, MMUCR_FREEPKT);
659
660                 return;
661         }
662         /*
663          * Point to the beginning of the packet
664          */
665         outw(BASE + POINTER_REG_W, PTR_AUTOINC | 0x0000);
666
667         /*
668          * Send the packet length (+6 for status, length and control byte)
669          * and the status word (set to zeros)
670          */
671         outw(BASE + DATA_REG_W, 0);
672         outb(BASE + DATA_REG_B, (length + 6) & 0xFF);
673         outb(BASE + DATA_REG_B, (length + 6) >> 8);
674
675         /*
676          * Get the packet from the kernel.  This will include the Ethernet
677          * frame header, MAC Addresses etc.
678          */
679         m = ifq_dequeue(&ifp->if_snd);
680
681         /*
682          * Push out the data to the card.
683          */
684         for (top = m; m != 0; m = m->m_next) {
685
686                 /*
687                  * Push out words.
688                  */
689                 outsw(BASE + DATA_REG_W, mtod(m, caddr_t), m->m_len / 2);
690
691                 /*
692                  * Push out remaining byte.
693                  */
694                 if (m->m_len & 1)
695                         outb(BASE + DATA_REG_B, *(mtod(m, caddr_t) + m->m_len - 1));
696         }
697
698         /*
699          * Push out padding.
700          */
701         while (pad > 1) {
702                 outw(BASE + DATA_REG_W, 0);
703                 pad -= 2;
704         }
705         if (pad)
706                 outb(BASE + DATA_REG_B, 0);
707
708         /*
709          * Push out control byte and unused packet byte The control byte is 0
710          * meaning the packet is even lengthed and no special CRC handling is
711          * desired.
712          */
713         outw(BASE + DATA_REG_W, 0);
714
715         /*
716          * Enable the interrupts and let the chipset deal with it Also set a
717          * watchdog in case we miss the interrupt.
718          */
719         mask = inb(BASE + INTR_MASK_REG_B) | (IM_TX_INT | IM_TX_EMPTY_INT);
720         outb(BASE + INTR_MASK_REG_B, mask);
721         sc->intr_mask = mask;
722         outw(BASE + MMU_CMD_REG_W, MMUCR_ENQUEUE);
723
724         BPF_MTAP(ifp, top);
725
726         ifp->if_opackets++;
727         m_freem(top);
728
729 try_start:
730
731         /*
732          * Now pass control to snstart() to queue any additional packets
733          */
734         ifp->if_flags &= ~IFF_OACTIVE;
735         snstart(ifp);
736
737         /*
738          * We've sent something, so we're active.  Set a watchdog in case the
739          * TX_EMPTY interrupt is lost.
740          */
741         ifp->if_flags |= IFF_OACTIVE;
742         ifp->if_timer = 1;
743 }
744
745
746 void
747 sn_intr(void *arg)
748 {
749         int             status, interrupts;
750         struct sn_softc *sc = (struct sn_softc *) arg;
751         struct ifnet   *ifp = &sc->arpcom.ac_if;
752
753         /*
754          * Chip state registers
755          */
756         u_char          mask;
757         u_char          packet_no;
758         u_short         tx_status;
759         u_short         card_stats;
760
761         crit_enter();
762
763         /*
764          * Clear the watchdog.
765          */
766         ifp->if_timer = 0;
767
768         SMC_SELECT_BANK(2);
769
770         /*
771          * Obtain the current interrupt mask and clear the hardware mask
772          * while servicing interrupts.
773          */
774         mask = inb(BASE + INTR_MASK_REG_B);
775         outb(BASE + INTR_MASK_REG_B, 0x00);
776
777         /*
778          * Get the set of interrupts which occurred and eliminate any which
779          * are masked.
780          */
781         interrupts = inb(BASE + INTR_STAT_REG_B);
782         status = interrupts & mask;
783
784         /*
785          * Now, process each of the interrupt types.
786          */
787
788         /*
789          * Receive Overrun.
790          */
791         if (status & IM_RX_OVRN_INT) {
792
793                 /*
794                  * Acknowlege Interrupt
795                  */
796                 SMC_SELECT_BANK(2);
797                 outb(BASE + INTR_ACK_REG_B, IM_RX_OVRN_INT);
798
799                 ++sc->arpcom.ac_if.if_ierrors;
800         }
801         /*
802          * Got a packet.
803          */
804         if (status & IM_RCV_INT) {
805 #if 1
806                 int             packet_number;
807
808                 SMC_SELECT_BANK(2);
809                 packet_number = inw(BASE + FIFO_PORTS_REG_W);
810
811                 if (packet_number & FIFO_REMPTY) {
812
813                         /*
814                          * we got called , but nothing was on the FIFO
815                          */
816                         printf("sn: Receive interrupt with nothing on FIFO\n");
817
818                         goto out;
819                 }
820 #endif
821                 snread(ifp);
822         }
823         /*
824          * An on-card memory allocation came through.
825          */
826         if (status & IM_ALLOC_INT) {
827
828                 /*
829                  * Disable this interrupt.
830                  */
831                 mask &= ~IM_ALLOC_INT;
832                 sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
833                 snresume(&sc->arpcom.ac_if);
834         }
835         /*
836          * TX Completion.  Handle a transmit error message. This will only be
837          * called when there is an error, because of the AUTO_RELEASE mode.
838          */
839         if (status & IM_TX_INT) {
840
841                 /*
842                  * Acknowlege Interrupt
843                  */
844                 SMC_SELECT_BANK(2);
845                 outb(BASE + INTR_ACK_REG_B, IM_TX_INT);
846
847                 packet_no = inw(BASE + FIFO_PORTS_REG_W);
848                 packet_no &= FIFO_TX_MASK;
849
850                 /*
851                  * select this as the packet to read from
852                  */
853                 outb(BASE + PACKET_NUM_REG_B, packet_no);
854
855                 /*
856                  * Position the pointer to the first word from this packet
857                  */
858                 outw(BASE + POINTER_REG_W, PTR_AUTOINC | PTR_READ | 0x0000);
859
860                 /*
861                  * Fetch the TX status word.  The value found here will be a
862                  * copy of the EPH_STATUS_REG_W at the time the transmit
863                  * failed.
864                  */
865                 tx_status = inw(BASE + DATA_REG_W);
866
867                 if (tx_status & EPHSR_TX_SUC) {
868                         device_printf(sc->dev, 
869                             "Successful packet caused interrupt\n");
870                 } else {
871                         ++sc->arpcom.ac_if.if_oerrors;
872                 }
873
874                 if (tx_status & EPHSR_LATCOL)
875                         ++sc->arpcom.ac_if.if_collisions;
876
877                 /*
878                  * Some of these errors will have disabled transmit.
879                  * Re-enable transmit now.
880                  */
881                 SMC_SELECT_BANK(0);
882
883 #ifdef SW_PAD
884                 outw(BASE + TXMIT_CONTROL_REG_W, TCR_ENABLE);
885 #else
886                 outw(BASE + TXMIT_CONTROL_REG_W, TCR_ENABLE | TCR_PAD_ENABLE);
887 #endif  /* SW_PAD */
888
889                 /*
890                  * kill the failed packet. Wait for the MMU to be un-busy.
891                  */
892                 SMC_SELECT_BANK(2);
893                 while (inw(BASE + MMU_CMD_REG_W) & MMUCR_BUSY)  /* NOTHING */
894                         ;
895                 outw(BASE + MMU_CMD_REG_W, MMUCR_FREEPKT);
896
897                 /*
898                  * Attempt to queue more transmits.
899                  */
900                 sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
901                 snstart(&sc->arpcom.ac_if);
902         }
903         /*
904          * Transmit underrun.  We use this opportunity to update transmit
905          * statistics from the card.
906          */
907         if (status & IM_TX_EMPTY_INT) {
908
909                 /*
910                  * Acknowlege Interrupt
911                  */
912                 SMC_SELECT_BANK(2);
913                 outb(BASE + INTR_ACK_REG_B, IM_TX_EMPTY_INT);
914
915                 /*
916                  * Disable this interrupt.
917                  */
918                 mask &= ~IM_TX_EMPTY_INT;
919
920                 SMC_SELECT_BANK(0);
921                 card_stats = inw(BASE + COUNTER_REG_W);
922
923                 /*
924                  * Single collisions
925                  */
926                 sc->arpcom.ac_if.if_collisions += card_stats & ECR_COLN_MASK;
927
928                 /*
929                  * Multiple collisions
930                  */
931                 sc->arpcom.ac_if.if_collisions += (card_stats & ECR_MCOLN_MASK) >> 4;
932
933                 SMC_SELECT_BANK(2);
934
935                 /*
936                  * Attempt to enqueue some more stuff.
937                  */
938                 sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
939                 snstart(&sc->arpcom.ac_if);
940         }
941         /*
942          * Some other error.  Try to fix it by resetting the adapter.
943          */
944         if (status & IM_EPH_INT) {
945                 snstop(sc);
946                 sninit(sc);
947         }
948
949 out:
950         /*
951          * Handled all interrupt sources.
952          */
953
954         SMC_SELECT_BANK(2);
955
956         /*
957          * Reestablish interrupts from mask which have not been deselected
958          * during this interrupt.  Note that the hardware mask, which was set
959          * to 0x00 at the start of this service routine, may have been
960          * updated by one or more of the interrupt handers and we must let
961          * those new interrupts stay enabled here.
962          */
963         mask |= inb(BASE + INTR_MASK_REG_B);
964         outb(BASE + INTR_MASK_REG_B, mask);
965         sc->intr_mask = mask;
966
967         crit_exit();
968 }
969
970 void
971 snread(struct ifnet *ifp)
972 {
973         struct sn_softc *sc = ifp->if_softc;
974         struct mbuf    *m;
975         short           status;
976         int             packet_number;
977         u_short         packet_length;
978         u_char         *data;
979
980         SMC_SELECT_BANK(2);
981 #if 0
982         packet_number = inw(BASE + FIFO_PORTS_REG_W);
983
984         if (packet_number & FIFO_REMPTY) {
985
986                 /*
987                  * we got called , but nothing was on the FIFO
988                  */
989                 printf("sn: Receive interrupt with nothing on FIFO\n");
990                 return;
991         }
992 #endif
993 read_another:
994
995         /*
996          * Start reading from the start of the packet. Since PTR_RCV is set,
997          * packet number is found in FIFO_PORTS_REG_W, FIFO_RX_MASK.
998          */
999         outw(BASE + POINTER_REG_W, PTR_READ | PTR_RCV | PTR_AUTOINC | 0x0000);
1000
1001         /*
1002          * First two words are status and packet_length
1003          */
1004         status = inw(BASE + DATA_REG_W);
1005         packet_length = inw(BASE + DATA_REG_W) & RLEN_MASK;
1006
1007         /*
1008          * The packet length contains 3 extra words: status, length, and a
1009          * extra word with the control byte.
1010          */
1011         packet_length -= 6;
1012
1013         /*
1014          * Account for receive errors and discard.
1015          */
1016         if (status & RS_ERRORS) {
1017                 ++ifp->if_ierrors;
1018                 goto out;
1019         }
1020         /*
1021          * A packet is received.
1022          */
1023
1024         /*
1025          * Adjust for odd-length packet.
1026          */
1027         if (status & RS_ODDFRAME)
1028                 packet_length++;
1029
1030         /*
1031          * Allocate a header mbuf from the kernel.
1032          */
1033         MGETHDR(m, MB_DONTWAIT, MT_DATA);
1034         if (m == NULL)
1035                 goto out;
1036
1037         m->m_pkthdr.rcvif = ifp;
1038         m->m_pkthdr.len = m->m_len = packet_length;
1039
1040         /*
1041          * Attach an mbuf cluster
1042          */
1043         MCLGET(m, MB_DONTWAIT);
1044
1045         /*
1046          * Insist on getting a cluster
1047          */
1048         if ((m->m_flags & M_EXT) == 0) {
1049                 m_freem(m);
1050                 ++ifp->if_ierrors;
1051                 printf("sn: snread() kernel memory allocation problem\n");
1052                 goto out;
1053         }
1054
1055         /*
1056          * Get packet, including link layer address, from interface.
1057          */
1058
1059         data = mtod(m, u_char *);
1060         insw(BASE + DATA_REG_W, data, packet_length >> 1);
1061         if (packet_length & 1) {
1062                 data += packet_length & ~1;
1063                 *data = inb(BASE + DATA_REG_B);
1064         }
1065         ++ifp->if_ipackets;
1066
1067         m->m_pkthdr.len = m->m_len = packet_length;
1068
1069         (*ifp->if_input)(ifp, m);
1070
1071 out:
1072
1073         /*
1074          * Error or good, tell the card to get rid of this packet Wait for
1075          * the MMU to be un-busy.
1076          */
1077         SMC_SELECT_BANK(2);
1078         while (inw(BASE + MMU_CMD_REG_W) & MMUCR_BUSY)  /* NOTHING */
1079                 ;
1080         outw(BASE + MMU_CMD_REG_W, MMUCR_RELEASE);
1081
1082         /*
1083          * Check whether another packet is ready
1084          */
1085         packet_number = inw(BASE + FIFO_PORTS_REG_W);
1086         if (packet_number & FIFO_REMPTY) {
1087                 return;
1088         }
1089         goto read_another;
1090 }
1091
1092
1093 /*
1094  * Handle IOCTLS.  This function is completely stolen from if_ep.c
1095  * As with its progenitor, it does not handle hardware address
1096  * changes.
1097  */
1098 static int
1099 snioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
1100 {
1101         struct sn_softc *sc = ifp->if_softc;
1102         int error = 0;
1103
1104         crit_enter();
1105
1106         switch (cmd) {
1107         case SIOCSIFFLAGS:
1108                 if ((ifp->if_flags & IFF_UP) == 0 && ifp->if_flags & IFF_RUNNING) {
1109                         ifp->if_flags &= ~IFF_RUNNING;
1110                         snstop(sc);
1111                         break;
1112                 } else {
1113                         /* reinitialize card on any parameter change */
1114                         sninit(sc);
1115                         break;
1116                 }
1117                 break;
1118
1119 #ifdef notdef
1120         case SIOCGHWADDR:
1121                 bcopy((caddr_t) sc->sc_addr, (caddr_t) & ifr->ifr_data,
1122                       sizeof(sc->sc_addr));
1123                 break;
1124 #endif
1125
1126         case SIOCADDMULTI:
1127             /* update multicast filter list. */
1128             sn_setmcast(sc);
1129             error = 0;
1130             break;
1131         case SIOCDELMULTI:
1132             /* update multicast filter list. */
1133             sn_setmcast(sc);
1134             error = 0;
1135             break;
1136         default:
1137                 error = ether_ioctl(ifp, cmd, data);
1138                 break;
1139         }
1140
1141         crit_exit();
1142
1143         return (error);
1144 }
1145
1146 void
1147 snreset(struct sn_softc *sc)
1148 {
1149         crit_enter();
1150
1151         snstop(sc);
1152         sninit(sc);
1153
1154         crit_exit();
1155 }
1156
1157 void
1158 snwatchdog(struct ifnet *ifp)
1159 {
1160         crit_enter();
1161
1162         sn_intr(ifp->if_softc);
1163
1164         crit_exit();
1165 }
1166
1167
1168 /* 1. zero the interrupt mask
1169  * 2. clear the enable receive flag
1170  * 3. clear the enable xmit flags
1171  */
1172 void
1173 snstop(struct sn_softc *sc)
1174 {
1175         
1176         struct ifnet   *ifp = &sc->arpcom.ac_if;
1177
1178         /*
1179          * Clear interrupt mask; disable all interrupts.
1180          */
1181         SMC_SELECT_BANK(2);
1182         outb(BASE + INTR_MASK_REG_B, 0x00);
1183
1184         /*
1185          * Disable transmitter and Receiver
1186          */
1187         SMC_SELECT_BANK(0);
1188         outw(BASE + RECV_CONTROL_REG_W, 0x0000);
1189         outw(BASE + TXMIT_CONTROL_REG_W, 0x0000);
1190
1191         /*
1192          * Cancel watchdog.
1193          */
1194         ifp->if_timer = 0;
1195 }
1196
1197
1198 int
1199 sn_activate(device_t dev)
1200 {
1201         struct sn_softc *sc = device_get_softc(dev);
1202         int err;
1203
1204         sc->port_rid = 0;
1205         sc->port_res = bus_alloc_resource(dev, SYS_RES_IOPORT, &sc->port_rid,
1206             0, ~0, SMC_IO_EXTENT, RF_ACTIVE);
1207         if (!sc->port_res) {
1208 #ifdef SN_DEBUG
1209                 device_printf(dev, "Cannot allocate ioport\n");
1210 #endif          
1211                 return ENOMEM;
1212         }
1213
1214         sc->irq_rid = 0;
1215         sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irq_rid, 
1216             RF_ACTIVE);
1217         if (!sc->irq_res) {
1218 #ifdef SN_DEBUG
1219                 device_printf(dev, "Cannot allocate irq\n");
1220 #endif
1221                 sn_deactivate(dev);
1222                 return ENOMEM;
1223         }
1224         err = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_NET, sn_intr, sc,
1225                              &sc->intrhand, NULL);
1226         if (err) {
1227                 sn_deactivate(dev);
1228                 return err;
1229         }
1230         
1231         sc->sn_io_addr = rman_get_start(sc->port_res);
1232         return (0);
1233 }
1234
1235 void
1236 sn_deactivate(device_t dev)
1237 {
1238         struct sn_softc *sc = device_get_softc(dev);
1239         
1240         if (sc->intrhand)
1241                 bus_teardown_intr(dev, sc->irq_res, sc->intrhand);
1242         sc->intrhand = 0;
1243         if (sc->port_res)
1244                 bus_release_resource(dev, SYS_RES_IOPORT, sc->port_rid, 
1245                     sc->port_res);
1246         sc->port_res = 0;
1247         if (sc->irq_res)
1248                 bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, 
1249                     sc->irq_res);
1250         sc->irq_res = 0;
1251         return;
1252 }
1253
1254 /*
1255  * Function: sn_probe( device_t dev, int pccard )
1256  *
1257  * Purpose:
1258  *      Tests to see if a given ioaddr points to an SMC9xxx chip.
1259  *      Tries to cause as little damage as possible if it's not a SMC chip.
1260  *      Returns a 0 on success
1261  *
1262  * Algorithm:
1263  *      (1) see if the high byte of BANK_SELECT is 0x33
1264  *      (2) compare the ioaddr with the base register's address
1265  *      (3) see if I recognize the chip ID in the appropriate register
1266  *
1267  *
1268  */
1269 int 
1270 sn_probe(device_t dev, int pccard)
1271 {
1272         struct sn_softc *sc = device_get_softc(dev);
1273         u_int           bank;
1274         u_short         revision_register;
1275         u_short         base_address_register;
1276         u_short         ioaddr;
1277         int             err;
1278
1279         if ((err = sn_activate(dev)) != 0)
1280                 return err;
1281
1282         ioaddr = sc->sn_io_addr;
1283
1284         /*
1285          * First, see if the high byte is 0x33
1286          */
1287         bank = inw(ioaddr + BANK_SELECT_REG_W);
1288         if ((bank & BSR_DETECT_MASK) != BSR_DETECT_VALUE) {
1289 #ifdef  SN_DEBUG
1290                 device_printf(dev, "test1 failed\n");
1291 #endif
1292                 goto error;
1293         }
1294         /*
1295          * The above MIGHT indicate a device, but I need to write to further
1296          * test this.  Go to bank 0, then test that the register still
1297          * reports the high byte is 0x33.
1298          */
1299         outw(ioaddr + BANK_SELECT_REG_W, 0x0000);
1300         bank = inw(ioaddr + BANK_SELECT_REG_W);
1301         if ((bank & BSR_DETECT_MASK) != BSR_DETECT_VALUE) {
1302 #ifdef  SN_DEBUG
1303                 device_printf(dev, "test2 failed\n");
1304 #endif
1305                 goto error;
1306         }
1307         /*
1308          * well, we've already written once, so hopefully another time won't
1309          * hurt.  This time, I need to switch the bank register to bank 1, so
1310          * I can access the base address register.  The contents of the
1311          * BASE_ADDR_REG_W register, after some jiggery pokery, is expected
1312          * to match the I/O port address where the adapter is being probed.
1313          */
1314         outw(ioaddr + BANK_SELECT_REG_W, 0x0001);
1315         base_address_register = inw(ioaddr + BASE_ADDR_REG_W);
1316
1317         /*
1318          * This test is nonsence on PC-card architecture, so if 
1319          * pccard == 1, skip this test. (hosokawa)
1320          */
1321         if (!pccard && (ioaddr != (base_address_register >> 3 & 0x3E0))) {
1322
1323                 /*
1324                  * Well, the base address register didn't match.  Must not
1325                  * have been a SMC chip after all.
1326                  */
1327                 /*
1328                  * printf("sn: ioaddr %x doesn't match card configuration
1329                  * (%x)\n", ioaddr, base_address_register >> 3 & 0x3E0 );
1330                  */
1331
1332 #ifdef  SN_DEBUG
1333                 device_printf(dev, "test3 failed ioaddr = 0x%x, "
1334                     "base_address_register = 0x%x\n", ioaddr,
1335                     base_address_register >> 3 & 0x3E0);
1336 #endif
1337                 goto error;
1338         }
1339         /*
1340          * Check if the revision register is something that I recognize.
1341          * These might need to be added to later, as future revisions could
1342          * be added.
1343          */
1344         outw(ioaddr + BANK_SELECT_REG_W, 0x3);
1345         revision_register = inw(ioaddr + REVISION_REG_W);
1346         if (!chip_ids[(revision_register >> 4) & 0xF]) {
1347
1348                 /*
1349                  * I don't regonize this chip, so...
1350                  */
1351 #ifdef  SN_DEBUG
1352                 device_printf(dev, "test4 failed\n");
1353 #endif
1354                 goto error;
1355         }
1356         /*
1357          * at this point I'll assume that the chip is an SMC9xxx. It might be
1358          * prudent to check a listing of MAC addresses against the hardware
1359          * address, or do some other tests.
1360          */
1361         sn_deactivate(dev);
1362         return 0;
1363  error:
1364         sn_deactivate(dev);
1365         return ENXIO;
1366 }
1367
1368 #define MCFSZ 8
1369
1370 static void
1371 sn_setmcast(struct sn_softc *sc)
1372 {
1373         struct ifnet *ifp = (struct ifnet *)sc;
1374         int flags;
1375
1376         /*
1377          * Set the receiver filter.  We want receive enabled and auto strip
1378          * of CRC from received packet.  If we are promiscuous then set that
1379          * bit too.
1380          */
1381         flags = RCR_ENABLE | RCR_STRIP_CRC;
1382   
1383         if (ifp->if_flags & IFF_PROMISC) {
1384                 flags |= RCR_PROMISC | RCR_ALMUL;
1385         } else if (ifp->if_flags & IFF_ALLMULTI) {
1386                 flags |= RCR_ALMUL;
1387         } else {
1388                 u_char mcf[MCFSZ];
1389                 if (sn_getmcf(&sc->arpcom, mcf)) {
1390                         /* set filter */
1391                         SMC_SELECT_BANK(3);
1392                         outw(BASE + MULTICAST1_REG_W,
1393                             ((u_short)mcf[1] << 8) |  mcf[0]);
1394                         outw(BASE + MULTICAST2_REG_W,
1395                             ((u_short)mcf[3] << 8) |  mcf[2]);
1396                         outw(BASE + MULTICAST3_REG_W,
1397                             ((u_short)mcf[5] << 8) |  mcf[4]);
1398                         outw(BASE + MULTICAST4_REG_W,
1399                             ((u_short)mcf[7] << 8) |  mcf[6]);
1400                 } else {
1401                         flags |= RCR_ALMUL;
1402                 }
1403         }
1404         SMC_SELECT_BANK(0);
1405         outw(BASE + RECV_CONTROL_REG_W, flags);
1406 }
1407
1408 static int
1409 sn_getmcf(struct arpcom *ac, u_char *mcf)
1410 {
1411         int i;
1412         u_int index, index2;
1413         u_char *af = (u_char *) mcf;
1414         struct ifmultiaddr *ifma;
1415
1416         bzero(mcf, MCFSZ);
1417
1418         for (ifma = ac->ac_if.if_multiaddrs.lh_first; ifma;
1419              ifma = ifma->ifma_link.le_next) {
1420             if (ifma->ifma_addr->sa_family != AF_LINK)
1421                 return 0;
1422             index = smc_crc(LLADDR((struct sockaddr_dl *)ifma->ifma_addr)) & 0x3f;
1423             index2 = 0;
1424             for (i = 0; i < 6; i++) {
1425                 index2 <<= 1;
1426                 index2 |= (index & 0x01);
1427                 index >>= 1;
1428             }
1429             af[index2 >> 3] |= 1 << (index2 & 7);
1430         }
1431         return 1;  /* use multicast filter */
1432 }
1433
1434 static u_int
1435 smc_crc(u_char *s)
1436 {
1437         int perByte;
1438         int perBit;
1439         const u_int poly = 0xedb88320;
1440         u_int v = 0xffffffff;
1441         u_char c;
1442   
1443         for (perByte = 0; perByte < ETHER_ADDR_LEN; perByte++) {
1444                 c = s[perByte];
1445                 for (perBit = 0; perBit < 8; perBit++) {
1446                         v = (v >> 1)^(((v ^ c) & 0x01) ? poly : 0);
1447                         c >>= 1;
1448                 }
1449         }
1450         return v;
1451 }