1 /* $NetBSD: if_eg.c,v 1.103 2022/09/17 17:00:02 thorpej Exp $ */
2
3 /*
4 * Copyright (c) 1993 Dean Huxley <dean@fsa.ca>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by Dean Huxley.
18 * 4. The name of Dean Huxley may not be used to endorse or promote products
19 * derived from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32 /*
33 * Support for 3Com 3c505 Etherlink+ card.
34 */
35
36 /*
37 * To do:
38 * - multicast
39 * - promiscuous
40 */
41
42 #include <sys/cdefs.h>
43 __KERNEL_RCSID(0, "$NetBSD: if_eg.c,v 1.103 2022/09/17 17:00:02 thorpej Exp $");
44
45 #include "opt_inet.h"
46
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/kmem.h>
50 #include <sys/mbuf.h>
51 #include <sys/socket.h>
52 #include <sys/ioctl.h>
53 #include <sys/errno.h>
54 #include <sys/syslog.h>
55 #include <sys/select.h>
56 #include <sys/device.h>
57 #include <sys/rndsource.h>
58
59 #include <net/if.h>
60 #include <net/if_dl.h>
61 #include <net/if_types.h>
62 #include <net/bpf.h>
63
64 #include <net/if_ether.h>
65
66 #ifdef INET
67 #include <netinet/in.h>
68 #include <netinet/in_systm.h>
69 #include <netinet/in_var.h>
70 #include <netinet/ip.h>
71 #include <netinet/if_inarp.h>
72 #endif
73
74 #include <sys/cpu.h>
75 #include <sys/intr.h>
76 #include <sys/bus.h>
77
78 #include <dev/isa/isavar.h>
79 #include <dev/isa/if_egreg.h>
80 #include <dev/isa/elink.h>
81
82 /* for debugging convenience */
83 #ifdef EGDEBUG
84 #define DPRINTF(x) printf x
85 #else
86 #define DPRINTF(x)
87 #endif
88
89 #define EG_INLEN 10
90 #define EG_BUFLEN 0x0670
91
92 #define EG_PCBLEN 64
93
94 /*
95 * Ethernet software status per interface.
96 */
97 struct eg_softc {
98 device_t sc_dev;
99 void *sc_ih;
100 struct ethercom sc_ethercom; /* Ethernet common part */
101 bus_space_tag_t sc_iot; /* bus space identifier */
102 bus_space_handle_t sc_ioh; /* i/o handle */
103 uint8_t eg_rom_major; /* Cards ROM version (major number) */
104 uint8_t eg_rom_minor; /* Cards ROM version (minor number) */
105 short eg_ram; /* Amount of RAM on the card */
106 uint8_t eg_pcb[EG_PCBLEN]; /* Primary Command Block buffer */
107 uint8_t eg_incount; /* Number of buffers currently used */
108 bool eg_txbusy; /* transmitter is busy */
109 void * eg_inbuf; /* Incoming packet buffer */
110 void * eg_outbuf; /* Outgoing packet buffer */
111
112 krndsource_t rnd_source;
113 };
114
115 static int egprobe(device_t, cfdata_t, void *);
116 static void egattach(device_t, device_t, void *);
117
118 CFATTACH_DECL_NEW(eg, sizeof(struct eg_softc),
119 egprobe, egattach, NULL, NULL);
120
121 static int egintr(void *);
122 static void eginit(struct eg_softc *);
123 static int egioctl(struct ifnet *, u_long, void *);
124 static void egrecv(struct eg_softc *);
125 static void egstart(struct ifnet *);
126 static void egwatchdog(struct ifnet *);
127 static void egreset(struct eg_softc *);
128 static void egread(struct eg_softc *, void *, int);
129 static struct mbuf *egget(struct eg_softc *, void *, int);
130 static void egstop(struct eg_softc *);
131
132 static inline void egprintpcb(uint8_t *);
133 static int egoutPCB(bus_space_tag_t, bus_space_handle_t, uint8_t);
134 static int egreadPCBstat(bus_space_tag_t, bus_space_handle_t, uint8_t);
135 static int egreadPCBready(bus_space_tag_t, bus_space_handle_t);
136 static int egwritePCB(bus_space_tag_t, bus_space_handle_t, uint8_t *);
137 static int egreadPCB(bus_space_tag_t, bus_space_handle_t, uint8_t *);
138
139 /*
140 * Support stuff
141 */
142
143 static inline void
egprintpcb(uint8_t * pcb)144 egprintpcb(uint8_t *pcb)
145 {
146 int i;
147
148 for (i = 0; i < pcb[1] + 2; i++)
149 DPRINTF(("pcb[%2d] = %x\n", i, pcb[i]));
150 }
151
152 static int
egoutPCB(bus_space_tag_t iot,bus_space_handle_t ioh,uint8_t b)153 egoutPCB(bus_space_tag_t iot, bus_space_handle_t ioh, uint8_t b)
154 {
155 int i;
156
157 for (i=0; i < 4000; i++) {
158 if (bus_space_read_1(iot, ioh, EG_STATUS) & EG_STAT_HCRE) {
159 bus_space_write_1(iot, ioh, EG_COMMAND, b);
160 return 0;
161 }
162 delay(10);
163 }
164 DPRINTF(("egoutPCB failed\n"));
165 return 1;
166 }
167
168 static int
egreadPCBstat(bus_space_tag_t iot,bus_space_handle_t ioh,uint8_t statb)169 egreadPCBstat(bus_space_tag_t iot, bus_space_handle_t ioh, uint8_t statb)
170 {
171 int i;
172
173 for (i=0; i < 5000; i++) {
174 if ((bus_space_read_1(iot, ioh, EG_STATUS) &
175 EG_PCB_STAT) != EG_PCB_NULL)
176 break;
177 delay(10);
178 }
179 if ((bus_space_read_1(iot, ioh, EG_STATUS) & EG_PCB_STAT) == statb)
180 return 0;
181 return 1;
182 }
183
184 static int
egreadPCBready(bus_space_tag_t iot,bus_space_handle_t ioh)185 egreadPCBready(bus_space_tag_t iot, bus_space_handle_t ioh)
186 {
187 int i;
188
189 for (i=0; i < 10000; i++) {
190 if (bus_space_read_1(iot, ioh, EG_STATUS) & EG_STAT_ACRF)
191 return 0;
192 delay(5);
193 }
194 DPRINTF(("PCB read not ready\n"));
195 return 1;
196 }
197
198 static int
egwritePCB(bus_space_tag_t iot,bus_space_handle_t ioh,uint8_t * pcb)199 egwritePCB(bus_space_tag_t iot, bus_space_handle_t ioh, uint8_t *pcb)
200 {
201 int i;
202 uint8_t len;
203
204 bus_space_write_1(iot, ioh, EG_CONTROL,
205 (bus_space_read_1(iot, ioh, EG_CONTROL) & ~EG_PCB_STAT) | EG_PCB_NULL);
206
207 len = pcb[1] + 2;
208 for (i = 0; i < len; i++)
209 egoutPCB(iot, ioh, pcb[i]);
210
211 for (i=0; i < 4000; i++) {
212 if (bus_space_read_1(iot, ioh, EG_STATUS) & EG_STAT_HCRE)
213 break;
214 delay(10);
215 }
216
217 bus_space_write_1(iot, ioh, EG_CONTROL,
218 (bus_space_read_1(iot, ioh, EG_CONTROL) & ~EG_PCB_STAT) | EG_PCB_DONE);
219
220 egoutPCB(iot, ioh, len);
221
222 if (egreadPCBstat(iot, ioh, EG_PCB_ACCEPT))
223 return 1;
224 return 0;
225 }
226
227 static int
egreadPCB(bus_space_tag_t iot,bus_space_handle_t ioh,uint8_t * pcb)228 egreadPCB(bus_space_tag_t iot, bus_space_handle_t ioh, uint8_t *pcb)
229 {
230 int i;
231
232 bus_space_write_1(iot, ioh, EG_CONTROL,
233 (bus_space_read_1(iot, ioh, EG_CONTROL) & ~EG_PCB_STAT) | EG_PCB_NULL);
234
235 memset(pcb, 0, EG_PCBLEN);
236
237 if (egreadPCBready(iot, ioh))
238 return 1;
239
240 pcb[0] = bus_space_read_1(iot, ioh, EG_COMMAND);
241
242 if (egreadPCBready(iot, ioh))
243 return 1;
244
245 pcb[1] = bus_space_read_1(iot, ioh, EG_COMMAND);
246
247 if (pcb[1] > 62) {
248 DPRINTF(("len %d too large\n", pcb[1]));
249 return 1;
250 }
251
252 for (i = 0; i < pcb[1]; i++) {
253 if (egreadPCBready(iot, ioh))
254 return 1;
255 pcb[2+i] = bus_space_read_1(iot, ioh, EG_COMMAND);
256 }
257 if (egreadPCBready(iot, ioh))
258 return 1;
259 if (egreadPCBstat(iot, ioh, EG_PCB_DONE))
260 return 1;
261 if (bus_space_read_1(iot, ioh, EG_COMMAND) != pcb[1] + 2) {
262 return 1;
263 }
264
265 bus_space_write_1(iot, ioh, EG_CONTROL,
266 (bus_space_read_1(iot, ioh, EG_CONTROL) &
267 ~EG_PCB_STAT) | EG_PCB_ACCEPT);
268
269 return 0;
270 }
271
272 /*
273 * Real stuff
274 */
275
276 static int
egprobe(device_t parent,cfdata_t match,void * aux)277 egprobe(device_t parent, cfdata_t match, void *aux)
278 {
279 struct isa_attach_args *ia = aux;
280 bus_space_tag_t iot = ia->ia_iot;
281 bus_space_handle_t ioh;
282 int i, rval;
283 static uint8_t pcb[EG_PCBLEN];
284
285 rval = 0;
286
287 /*
288 * XXX This probe is slow. If there are no ISA expansion slots,
289 * then skip it.
290 */
291 if (isa_get_slotcount() == 0)
292 return (0);
293
294 if (ia->ia_nio < 1)
295 return (0);
296 if (ia->ia_nirq < 1)
297 return (0);
298
299 if (ISA_DIRECT_CONFIG(ia))
300 return (0);
301
302 /* Disallow wildcarded i/o address. */
303 if (ia->ia_io[0].ir_addr == ISA_UNKNOWN_PORT)
304 return (0);
305
306 /* Disallow wildcarded IRQ. */
307 if (ia->ia_irq[0].ir_irq == ISA_UNKNOWN_IRQ)
308 return (0);
309
310 if ((ia->ia_io[0].ir_addr & ~0x07f0) != 0) {
311 DPRINTF(("Weird iobase %x\n", ia->ia_io[0].ir_addr));
312 return 0;
313 }
314
315 /* Map i/o space. */
316 if (bus_space_map(iot, ia->ia_io[0].ir_addr, 0x08, 0, &ioh)) {
317 DPRINTF(("egprobe: can't map i/o space in probe\n"));
318 return 0;
319 }
320
321 /* hard reset card */
322 bus_space_write_1(iot, ioh, EG_CONTROL, EG_CTL_RESET);
323 bus_space_write_1(iot, ioh, EG_CONTROL, 0);
324 for (i = 0; i < 500; i++) {
325 delay(1000);
326 if ((bus_space_read_1(iot, ioh, EG_STATUS) &
327 EG_PCB_STAT) == EG_PCB_NULL)
328 break;
329 }
330 if ((bus_space_read_1(iot, ioh, EG_STATUS) & EG_PCB_STAT) != EG_PCB_NULL) {
331 DPRINTF(("egprobe: Reset failed\n"));
332 goto out;
333 }
334 pcb[0] = EG_CMD_GETINFO; /* Get Adapter Info */
335 pcb[1] = 0;
336 if (egwritePCB(iot, ioh, pcb) != 0)
337 goto out;
338
339 if ((egreadPCB(iot, ioh, pcb) != 0) ||
340 pcb[0] != EG_RSP_GETINFO || /* Get Adapter Info Response */
341 pcb[1] != 0x0a) {
342 egprintpcb(pcb);
343 goto out;
344 }
345
346 ia->ia_nio = 1;
347 ia->ia_io[0].ir_size = 0x08;
348
349 ia->ia_nirq = 1;
350
351 ia->ia_niomem = 0;
352 ia->ia_ndrq = 0;
353
354 rval = 1;
355
356 out:
357 bus_space_unmap(iot, ioh, 0x08);
358 return rval;
359 }
360
361 static void
egattach(device_t parent,device_t self,void * aux)362 egattach(device_t parent, device_t self, void *aux)
363 {
364 struct eg_softc *sc = device_private(self);
365 struct isa_attach_args *ia = aux;
366 bus_space_tag_t iot = ia->ia_iot;
367 bus_space_handle_t ioh;
368 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
369 uint8_t myaddr[ETHER_ADDR_LEN];
370
371 sc->sc_dev = self;
372
373 printf("\n");
374
375 /* Map i/o space. */
376 if (bus_space_map(iot, ia->ia_io[0].ir_addr, 0x08, 0, &ioh)) {
377 aprint_error_dev(self, "can't map i/o space\n");
378 return;
379 }
380
381 sc->sc_iot = iot;
382 sc->sc_ioh = ioh;
383
384 sc->eg_pcb[0] = EG_CMD_GETINFO; /* Get Adapter Info */
385 sc->eg_pcb[1] = 0;
386 if (egwritePCB(iot, ioh, sc->eg_pcb) != 0) {
387 aprint_error_dev(self, "error requesting adapter info\n");
388 return;
389 }
390 if (egreadPCB(iot, ioh, sc->eg_pcb) != 0) {
391 egprintpcb(sc->eg_pcb);
392 aprint_error_dev(self, "error reading adapter info\n");
393 return;
394 }
395
396 if (sc->eg_pcb[0] != EG_RSP_GETINFO || /* Get Adapter Info Response */
397 sc->eg_pcb[1] != 0x0a) {
398 egprintpcb(sc->eg_pcb);
399 aprint_error_dev(self, "bogus adapter info\n");
400 return;
401 }
402
403 sc->eg_rom_major = sc->eg_pcb[3];
404 sc->eg_rom_minor = sc->eg_pcb[2];
405 sc->eg_ram = sc->eg_pcb[6] | (sc->eg_pcb[7] << 8);
406
407 egstop(sc);
408
409 sc->eg_pcb[0] = EG_CMD_GETEADDR; /* Get Station address */
410 sc->eg_pcb[1] = 0;
411 if (egwritePCB(iot, ioh, sc->eg_pcb) != 0) {
412 aprint_error_dev(self, "can't send Get Station Address\n");
413 return;
414 }
415 if (egreadPCB(iot, ioh, sc->eg_pcb) != 0) {
416 aprint_error_dev(self, "can't read station address\n");
417 egprintpcb(sc->eg_pcb);
418 return;
419 }
420
421 /* check Get station address response */
422 if (sc->eg_pcb[0] != EG_RSP_GETEADDR || sc->eg_pcb[1] != 0x06) {
423 aprint_error_dev(self, "card responded with garbage (1)\n");
424 egprintpcb(sc->eg_pcb);
425 return;
426 }
427 memcpy(myaddr, &sc->eg_pcb[2], ETHER_ADDR_LEN);
428
429 aprint_normal_dev(self, "ROM v%d.%02d %dk address %s\n",
430 sc->eg_rom_major, sc->eg_rom_minor, sc->eg_ram,
431 ether_sprintf(myaddr));
432
433 sc->eg_pcb[0] = EG_CMD_SETEADDR; /* Set station address */
434 if (egwritePCB(iot, ioh, sc->eg_pcb) != 0) {
435 aprint_error_dev(self, "can't send Set Station Address\n");
436 return;
437 }
438 if (egreadPCB(iot, ioh, sc->eg_pcb) != 0) {
439 aprint_error_dev(self,
440 "can't read Set Station Address status\n");
441 egprintpcb(sc->eg_pcb);
442 return;
443 }
444 if (sc->eg_pcb[0] != EG_RSP_SETEADDR || sc->eg_pcb[1] != 0x02 ||
445 sc->eg_pcb[2] != 0 || sc->eg_pcb[3] != 0) {
446 aprint_error_dev(self, "card responded with garbage (2)\n");
447 egprintpcb(sc->eg_pcb);
448 return;
449 }
450
451 /* Initialize ifnet structure. */
452 strlcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
453 ifp->if_softc = sc;
454 ifp->if_start = egstart;
455 ifp->if_ioctl = egioctl;
456 ifp->if_watchdog = egwatchdog;
457 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX;
458 IFQ_SET_READY(&ifp->if_snd);
459
460 /* Now we can attach the interface. */
461 if_attach(ifp);
462 ether_ifattach(ifp, myaddr);
463
464 sc->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq[0].ir_irq,
465 IST_EDGE, IPL_NET, egintr, sc);
466
467 rnd_attach_source(&sc->rnd_source, device_xname(sc->sc_dev),
468 RND_TYPE_NET, RND_FLAG_DEFAULT);
469 }
470
471 static void
eginit(struct eg_softc * sc)472 eginit(struct eg_softc *sc)
473 {
474 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
475 bus_space_tag_t iot = sc->sc_iot;
476 bus_space_handle_t ioh = sc->sc_ioh;
477
478 /* soft reset the board */
479 bus_space_write_1(iot, ioh, EG_CONTROL, EG_CTL_FLSH);
480 delay(100);
481 bus_space_write_1(iot, ioh, EG_CONTROL, EG_CTL_ATTN);
482 delay(100);
483 bus_space_write_1(iot, ioh, EG_CONTROL, 0);
484 delay(200);
485
486 sc->eg_pcb[0] = EG_CMD_CONFIG82586; /* Configure 82586 */
487 sc->eg_pcb[1] = 2;
488 sc->eg_pcb[2] = 3; /* receive broadcast & multicast */
489 sc->eg_pcb[3] = 0;
490 if (egwritePCB(iot, ioh, sc->eg_pcb) != 0)
491 aprint_error_dev(sc->sc_dev, "can't send Configure 82586\n");
492
493 if (egreadPCB(iot, ioh, sc->eg_pcb) != 0) {
494 aprint_error_dev(sc->sc_dev,
495 "can't read Configure 82586 status\n");
496 egprintpcb(sc->eg_pcb);
497 } else if (sc->eg_pcb[2] != 0 || sc->eg_pcb[3] != 0)
498 aprint_error_dev(sc->sc_dev,"configure card command failed\n");
499
500 if (sc->eg_inbuf == NULL) {
501 sc->eg_inbuf = kmem_alloc(EG_BUFLEN, KM_NOSLEEP);
502 if (sc->eg_inbuf == NULL) {
503 aprint_error_dev(sc->sc_dev, "can't allocate inbuf\n");
504 panic("eginit");
505 }
506 }
507 sc->eg_incount = 0;
508
509 if (sc->eg_outbuf == NULL) {
510 sc->eg_outbuf = kmem_alloc(EG_BUFLEN, KM_NOSLEEP);
511 if (sc->eg_outbuf == NULL) {
512 aprint_error_dev(sc->sc_dev,"can't allocate outbuf\n");
513 panic("eginit");
514 }
515 }
516
517 bus_space_write_1(iot, ioh, EG_CONTROL, EG_CTL_CMDE);
518
519 sc->eg_incount = 0;
520 egrecv(sc);
521
522 /* Interface is now `running', with no output active. */
523 ifp->if_flags |= IFF_RUNNING;
524 sc->eg_txbusy = false;
525
526 /* Attempt to start output, if any. */
527 egstart(ifp);
528 }
529
530 static void
egrecv(struct eg_softc * sc)531 egrecv(struct eg_softc *sc)
532 {
533
534 while (sc->eg_incount < EG_INLEN) {
535 sc->eg_pcb[0] = EG_CMD_RECVPACKET;
536 sc->eg_pcb[1] = 0x08;
537 sc->eg_pcb[2] = 0; /* address not used.. we send zero */
538 sc->eg_pcb[3] = 0;
539 sc->eg_pcb[4] = 0;
540 sc->eg_pcb[5] = 0;
541 sc->eg_pcb[6] = EG_BUFLEN & 0xff; /* our buffer size */
542 sc->eg_pcb[7] = (EG_BUFLEN >> 8) & 0xff;
543 sc->eg_pcb[8] = 0; /* timeout, 0 == none */
544 sc->eg_pcb[9] = 0;
545 if (egwritePCB(sc->sc_iot, sc->sc_ioh, sc->eg_pcb) != 0)
546 break;
547 sc->eg_incount++;
548 }
549 }
550
551 static void
egstart(struct ifnet * ifp)552 egstart(struct ifnet *ifp)
553 {
554 struct eg_softc *sc = ifp->if_softc;
555 bus_space_tag_t iot = sc->sc_iot;
556 bus_space_handle_t ioh = sc->sc_ioh;
557 struct mbuf *m0;
558 int len;
559 uint16_t *ptr;
560
561 /* Don't transmit if interface is busy or not running */
562 if ((ifp->if_flags & IFF_RUNNING) == 0)
563 return;
564
565 if (sc->eg_txbusy)
566 return;
567
568 loop:
569 /* Dequeue the next datagram. */
570 IFQ_DEQUEUE(&ifp->if_snd, m0);
571 if (m0 == 0)
572 return;
573
574 sc->eg_txbusy = true;
575
576 /* We need to use m->m_pkthdr.len, so require the header */
577 KASSERT(m0->m_flags & M_PKTHDR);
578 len = uimax(m0->m_pkthdr.len, ETHER_MIN_LEN - ETHER_CRC_LEN);
579
580 bpf_mtap(ifp, m0, BPF_D_OUT);
581
582 sc->eg_pcb[0] = EG_CMD_SENDPACKET;
583 sc->eg_pcb[1] = 0x06;
584 sc->eg_pcb[2] = 0; /* address not used, we send zero */
585 sc->eg_pcb[3] = 0;
586 sc->eg_pcb[4] = 0;
587 sc->eg_pcb[5] = 0;
588 sc->eg_pcb[6] = len; /* length of packet */
589 sc->eg_pcb[7] = len >> 8;
590 if (egwritePCB(iot, ioh, sc->eg_pcb) != 0) {
591 aprint_error_dev(sc->sc_dev,
592 "can't send Send Packet command\n");
593 if_statinc(ifp, if_oerrors);
594 sc->eg_txbusy = false;
595 m_freem(m0);
596 goto loop;
597 }
598
599 m_copydata(m0, 0, m0->m_pkthdr.len, sc->eg_outbuf);
600 if (len > m0->m_pkthdr.len) {
601 memset((uint8_t *)sc->eg_outbuf + m0->m_pkthdr.len, 0,
602 len - m0->m_pkthdr.len);
603 }
604
605 /* set direction bit: host -> adapter */
606 bus_space_write_1(iot, ioh, EG_CONTROL,
607 bus_space_read_1(iot, ioh, EG_CONTROL) & ~EG_CTL_DIR);
608
609 for (ptr = (uint16_t *) sc->eg_outbuf; len > 0; len -= 2) {
610 bus_space_write_2(iot, ioh, EG_DATA, *ptr++);
611 while (!(bus_space_read_1(iot, ioh, EG_STATUS) & EG_STAT_HRDY))
612 ; /* XXX need timeout here */
613 }
614
615 m_freem(m0);
616 }
617
618 static int
egintr(void * arg)619 egintr(void *arg)
620 {
621 struct eg_softc *sc = arg;
622 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
623 bus_space_tag_t iot = sc->sc_iot;
624 bus_space_handle_t ioh = sc->sc_ioh;
625 int i, len, serviced;
626 uint16_t *ptr;
627
628 serviced = 0;
629
630 while (bus_space_read_1(iot, ioh, EG_STATUS) & EG_STAT_ACRF) {
631 egreadPCB(iot, ioh, sc->eg_pcb);
632 switch (sc->eg_pcb[0]) {
633 case EG_RSP_RECVPACKET:
634 len = sc->eg_pcb[6] | (sc->eg_pcb[7] << 8);
635
636 /* Set direction bit : Adapter -> host */
637 bus_space_write_1(iot, ioh, EG_CONTROL,
638 bus_space_read_1(iot, ioh, EG_CONTROL) | EG_CTL_DIR);
639
640 for (ptr = (uint16_t *) sc->eg_inbuf;
641 len > 0; len -= 2) {
642 while (!(bus_space_read_1(iot, ioh, EG_STATUS) &
643 EG_STAT_HRDY))
644 ;
645 *ptr++ = bus_space_read_2(iot, ioh, EG_DATA);
646 }
647
648 len = sc->eg_pcb[8] | (sc->eg_pcb[9] << 8);
649 egread(sc, sc->eg_inbuf, len);
650
651 sc->eg_incount--;
652 egrecv(sc);
653 serviced = 1;
654 break;
655
656 case EG_RSP_SENDPACKET:
657 if (sc->eg_pcb[6] || sc->eg_pcb[7]) {
658 DPRINTF(("%s: packet dropped\n",
659 device_xname(sc->sc_dev)));
660 if_statinc(ifp, if_oerrors);
661 } else
662 if_statinc(ifp, if_opackets);
663 if (sc->eg_pcb[8] & 0xf)
664 if_statadd(ifp, if_collisions,
665 sc->eg_pcb[8] & 0xf);
666 sc->eg_txbusy = false;
667 egstart(&sc->sc_ethercom.ec_if);
668 serviced = 1;
669 break;
670
671 /* XXX byte-order and type-size bugs here... */
672 case EG_RSP_GETSTATS:
673 DPRINTF(("%s: Card Statistics\n",
674 device_xname(sc->sc_dev)));
675 memcpy(&i, &sc->eg_pcb[2], sizeof(i));
676 DPRINTF(("Receive Packets %d\n", i));
677 memcpy(&i, &sc->eg_pcb[6], sizeof(i));
678 DPRINTF(("Transmit Packets %d\n", i));
679 DPRINTF(("CRC errors %d\n",
680 *(short *) &sc->eg_pcb[10]));
681 DPRINTF(("alignment errors %d\n",
682 *(short *) &sc->eg_pcb[12]));
683 DPRINTF(("no resources errors %d\n",
684 *(short *) &sc->eg_pcb[14]));
685 DPRINTF(("overrun errors %d\n",
686 *(short *) &sc->eg_pcb[16]));
687 serviced = 1;
688 break;
689
690 default:
691 printf("%s: egintr: Unknown response %x??\n",
692 device_xname(sc->sc_dev), sc->eg_pcb[0]);
693 egprintpcb(sc->eg_pcb);
694 break;
695 }
696
697 rnd_add_uint32(&sc->rnd_source, sc->eg_pcb[0]);
698 }
699
700 return serviced;
701 }
702
703 /*
704 * Pass a packet up to the higher levels.
705 */
706 static void
egread(struct eg_softc * sc,void * buf,int len)707 egread(struct eg_softc *sc, void *buf, int len)
708 {
709 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
710 struct mbuf *m;
711
712 if (len <= sizeof(struct ether_header) ||
713 len > ETHER_MAX_LEN) {
714 aprint_error_dev(sc->sc_dev,
715 "invalid packet size %d; dropping\n", len);
716 if_statinc(ifp, if_ierrors);
717 return;
718 }
719
720 /* Pull packet off interface. */
721 m = egget(sc, buf, len);
722 if (m == 0) {
723 if_statinc(ifp, if_ierrors);
724 return;
725 }
726
727 if_percpuq_enqueue(ifp->if_percpuq, m);
728 }
729
730 /*
731 * convert buf into mbufs
732 */
733 static struct mbuf *
egget(struct eg_softc * sc,void * buf,int totlen)734 egget(struct eg_softc *sc, void *buf, int totlen)
735 {
736 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
737 struct mbuf *m, *m0, *newm;
738 int len;
739
740 MGETHDR(m0, M_DONTWAIT, MT_DATA);
741 if (m0 == 0)
742 return (0);
743 m_set_rcvif(m0, ifp);
744 m0->m_pkthdr.len = totlen;
745 len = MHLEN;
746 m = m0;
747
748 while (totlen > 0) {
749 if (totlen >= MINCLSIZE) {
750 MCLGET(m, M_DONTWAIT);
751 if ((m->m_flags & M_EXT) == 0)
752 goto bad;
753 len = MCLBYTES;
754 }
755
756 m->m_len = len = uimin(totlen, len);
757 memcpy(mtod(m, void *), buf, len);
758 buf = (char *)buf + len;
759
760 totlen -= len;
761 if (totlen > 0) {
762 MGET(newm, M_DONTWAIT, MT_DATA);
763 if (newm == 0)
764 goto bad;
765 len = MLEN;
766 m = m->m_next = newm;
767 }
768 }
769
770 return (m0);
771
772 bad:
773 m_freem(m0);
774 return (0);
775 }
776
777 static int
egioctl(struct ifnet * ifp,unsigned long cmd,void * data)778 egioctl(struct ifnet *ifp, unsigned long cmd, void *data)
779 {
780 struct eg_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 SIOCINITIFADDR:
789 ifp->if_flags |= IFF_UP;
790
791 eginit(sc);
792 switch (ifa->ifa_addr->sa_family) {
793 #ifdef INET
794 case AF_INET:
795 arp_ifinit(ifp, ifa);
796 break;
797 #endif
798 default:
799 break;
800 }
801 break;
802
803 case SIOCSIFFLAGS:
804 if ((error = ifioctl_common(ifp, cmd, data)) != 0)
805 break;
806 /* XXX re-use ether_ioctl() */
807 switch (ifp->if_flags & (IFF_UP|IFF_RUNNING)) {
808 case IFF_RUNNING:
809 /*
810 * If interface is marked down and it is running, then
811 * stop it.
812 */
813 egstop(sc);
814 ifp->if_flags &= ~IFF_RUNNING;
815 break;
816 case IFF_UP:
817 /*
818 * If interface is marked up and it is stopped, then
819 * start it.
820 */
821 eginit(sc);
822 break;
823 default:
824 sc->eg_pcb[0] = EG_CMD_GETSTATS;
825 sc->eg_pcb[1] = 0;
826 if (egwritePCB(sc->sc_iot, sc->sc_ioh, sc->eg_pcb) != 0) {
827 DPRINTF(("write error\n"));
828 }
829 /*
830 * XXX deal with flags changes:
831 * IFF_MULTICAST, IFF_PROMISC,
832 * IFF_LINK0, IFF_LINK1,
833 */
834 break;
835 }
836 break;
837
838 default:
839 error = ether_ioctl(ifp, cmd, data);
840 break;
841 }
842
843 splx(s);
844 return error;
845 }
846
847 static void
egreset(struct eg_softc * sc)848 egreset(struct eg_softc *sc)
849 {
850 int s;
851
852 DPRINTF(("%s: egreset()\n", device_xname(sc->sc_dev)));
853 s = splnet();
854 egstop(sc);
855 eginit(sc);
856 splx(s);
857 }
858
859 static void
egwatchdog(struct ifnet * ifp)860 egwatchdog(struct ifnet *ifp)
861 {
862 struct eg_softc *sc = ifp->if_softc;
863
864 log(LOG_ERR, "%s: device timeout\n", device_xname(sc->sc_dev));
865 if_statinc(ifp, if_oerrors);
866
867 egreset(sc);
868 }
869
870 static void
egstop(struct eg_softc * sc)871 egstop(struct eg_softc *sc)
872 {
873
874 bus_space_write_1(sc->sc_iot, sc->sc_ioh, EG_CONTROL, 0);
875 }
876