FreeBSD/Linux Kernel Cross Reference
sys/dev/ic/mb86960.c
1 /* $NetBSD: mb86960.c,v 1.57 2003/11/02 11:07:45 wiz Exp $ */
2
3 /*
4 * All Rights Reserved, Copyright (C) Fujitsu Limited 1995
5 *
6 * This software may be used, modified, copied, distributed, and sold, in
7 * both source and binary form provided that the above copyright, these
8 * terms and the following disclaimer are retained. The name of the author
9 * and/or the contributor may not be used to endorse or promote products
10 * derived from this software without specific prior written permission.
11 *
12 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND THE CONTRIBUTOR ``AS IS'' AND
13 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
14 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
15 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR THE CONTRIBUTOR BE LIABLE
16 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
17 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
18 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION.
19 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
20 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
21 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
22 * SUCH DAMAGE.
23 */
24
25 /*
26 * Portions copyright (C) 1993, David Greenman. This software may be used,
27 * modified, copied, distributed, and sold, in both source and binary form
28 * provided that the above copyright and these terms are retained. Under no
29 * circumstances is the author responsible for the proper functioning of this
30 * software, nor does the author assume any responsibility for damages
31 * incurred with its use.
32 */
33
34 #include <sys/cdefs.h>
35 __KERNEL_RCSID(0, "$NetBSD: mb86960.c,v 1.57 2003/11/02 11:07:45 wiz Exp $");
36
37 /*
38 * Device driver for Fujitsu MB86960A/MB86965A based Ethernet cards.
39 * Contributed by M.S. <seki@sysrap.cs.fujitsu.co.jp>
40 *
41 * This version is intended to be a generic template for various
42 * MB86960A/MB86965A based Ethernet cards. It currently supports
43 * Fujitsu FMV-180 series (i.e., FMV-181 and FMV-182) and Allied-
44 * Telesis AT1700 series and RE2000 series. There are some
45 * unnecessary hooks embedded, which are primarily intended to support
46 * other types of Ethernet cards, but the author is not sure whether
47 * they are useful.
48 */
49
50 #include "opt_inet.h"
51 #include "opt_ns.h"
52 #include "bpfilter.h"
53 #include "rnd.h"
54
55 #include <sys/param.h>
56 #include <sys/systm.h>
57 #include <sys/errno.h>
58 #include <sys/ioctl.h>
59 #include <sys/mbuf.h>
60 #include <sys/socket.h>
61 #include <sys/syslog.h>
62 #include <sys/device.h>
63 #if NRND > 0
64 #include <sys/rnd.h>
65 #endif
66
67 #include <net/if.h>
68 #include <net/if_dl.h>
69 #include <net/if_types.h>
70 #include <net/if_media.h>
71 #include <net/if_ether.h>
72
73 #ifdef INET
74 #include <netinet/in.h>
75 #include <netinet/in_systm.h>
76 #include <netinet/in_var.h>
77 #include <netinet/ip.h>
78 #include <netinet/if_inarp.h>
79 #endif
80
81 #ifdef NS
82 #include <netns/ns.h>
83 #include <netns/ns_if.h>
84 #endif
85
86 #if NBPFILTER > 0
87 #include <net/bpf.h>
88 #include <net/bpfdesc.h>
89 #endif
90
91 #include <machine/bus.h>
92
93 #include <dev/ic/mb86960reg.h>
94 #include <dev/ic/mb86960var.h>
95
96 #ifndef __BUS_SPACE_HAS_STREAM_METHODS
97 #define bus_space_write_stream_2 bus_space_write_2
98 #define bus_space_write_multi_stream_2 bus_space_write_multi_2
99 #define bus_space_read_multi_stream_2 bus_space_read_multi_2
100 #endif /* __BUS_SPACE_HAS_STREAM_METHODS */
101
102 /* Standard driver entry points. These can be static. */
103 void mb86960_init __P((struct mb86960_softc *));
104 int mb86960_ioctl __P((struct ifnet *, u_long, caddr_t));
105 void mb86960_start __P((struct ifnet *));
106 void mb86960_reset __P((struct mb86960_softc *));
107 void mb86960_watchdog __P((struct ifnet *));
108
109 /* Local functions. Order of declaration is confused. FIXME. */
110 int mb86960_get_packet __P((struct mb86960_softc *, u_int));
111 void mb86960_stop __P((struct mb86960_softc *));
112 void mb86960_tint __P((struct mb86960_softc *, u_int8_t));
113 void mb86960_rint __P((struct mb86960_softc *, u_int8_t));
114 static __inline__
115 void mb86960_xmit __P((struct mb86960_softc *));
116 void mb86960_write_mbufs __P((struct mb86960_softc *, struct mbuf *));
117 static __inline__
118 void mb86960_droppacket __P((struct mb86960_softc *));
119 void mb86960_getmcaf __P((struct ethercom *, u_int8_t *));
120 void mb86960_setmode __P((struct mb86960_softc *));
121 void mb86960_loadmar __P((struct mb86960_softc *));
122
123 int mb86960_mediachange __P((struct ifnet *));
124 void mb86960_mediastatus __P((struct ifnet *, struct ifmediareq *));
125
126 #if FE_DEBUG >= 1
127 void mb86960_dump __P((int, struct mb86960_softc *));
128 #endif
129
130 void
131 mb86960_attach(sc, myea)
132 struct mb86960_softc *sc;
133 u_int8_t *myea;
134 {
135 bus_space_tag_t bst = sc->sc_bst;
136 bus_space_handle_t bsh = sc->sc_bsh;
137
138 /* Register values which depend on board design. */
139 sc->proto_dlcr4 = FE_D4_LBC_DISABLE | FE_D4_CNTRL;
140 sc->proto_dlcr5 = 0;
141 sc->proto_dlcr7 = FE_D7_BYTSWP_LH;
142 if ((sc->sc_flags & FE_FLAGS_MB86960) != 0)
143 sc->proto_dlcr7 |= FE_D7_ED_TEST; /* XXX */
144 sc->proto_bmpr13 = FE_B13_TPTYPE_UTP | FE_B13_PORT_AUTO;
145
146 /*
147 * Program the 86960 as following defaults:
148 * SRAM: 32KB, 100ns, byte-wide access.
149 * Transmission buffer: 4KB x 2.
150 * System bus interface: 16 bits.
151 * These values except TXBSIZE should be modified as per
152 * sc_flags which is set in MD attachments, because they
153 * are hard-wired on the board. Modifying TXBSIZE will affect
154 * the driver performance.
155 */
156 sc->proto_dlcr6 = FE_D6_BUFSIZ_32KB | FE_D6_TXBSIZ_2x4KB |
157 FE_D6_BBW_BYTE | FE_D6_SRAM_100ns;
158 if (sc->sc_flags & FE_FLAGS_SBW_BYTE)
159 sc->proto_dlcr6 |= FE_D6_SBW_BYTE;
160 if (sc->sc_flags & FE_FLAGS_SRAM_150ns)
161 sc->proto_dlcr6 &= ~FE_D6_SRAM_100ns;
162
163 /*
164 * Minimum initialization of the hardware.
165 * We write into registers; hope I/O ports have no
166 * overlap with other boards.
167 */
168
169 /* Initialize 86960. */
170 bus_space_write_1(bst, bsh, FE_DLCR6,
171 sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
172 delay(200);
173
174 #ifdef DIAGNOSTIC
175 if (myea == NULL) {
176 printf("%s: ethernet address shouldn't be NULL\n",
177 sc->sc_dev.dv_xname);
178 panic("NULL ethernet address");
179 }
180 #endif
181 memcpy(sc->sc_enaddr, myea, sizeof(sc->sc_enaddr));
182
183 /* Disable all interrupts. */
184 bus_space_write_1(bst, bsh, FE_DLCR2, 0);
185 bus_space_write_1(bst, bsh, FE_DLCR3, 0);
186 }
187
188 /*
189 * Install interface into kernel networking data structures
190 */
191 void
192 mb86960_config(sc, media, nmedia, defmedia)
193 struct mb86960_softc *sc;
194 int *media, nmedia, defmedia;
195 {
196 struct cfdata *cf = sc->sc_dev.dv_cfdata;
197 struct ifnet *ifp = &sc->sc_ec.ec_if;
198 int i;
199
200 /* Stop the 86960. */
201 mb86960_stop(sc);
202
203 /* Initialize ifnet structure. */
204 strcpy(ifp->if_xname, sc->sc_dev.dv_xname);
205 ifp->if_softc = sc;
206 ifp->if_start = mb86960_start;
207 ifp->if_ioctl = mb86960_ioctl;
208 ifp->if_watchdog = mb86960_watchdog;
209 ifp->if_flags =
210 IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS | IFF_MULTICAST;
211 IFQ_SET_READY(&ifp->if_snd);
212
213 #if FE_DEBUG >= 3
214 log(LOG_INFO, "%s: mb86960_config()\n", sc->sc_dev.dv_xname);
215 mb86960_dump(LOG_INFO, sc);
216 #endif
217
218 #if FE_SINGLE_TRANSMISSION
219 /* Override txb config to allocate minimum. */
220 sc->proto_dlcr6 &= ~FE_D6_TXBSIZ;
221 sc->proto_dlcr6 |= FE_D6_TXBSIZ_2x2KB;
222 #endif
223
224 /* Modify hardware config if it is requested. */
225 if ((cf->cf_flags & FE_FLAGS_OVERRIDE_DLCR6) != 0)
226 sc->proto_dlcr6 = cf->cf_flags & FE_FLAGS_DLCR6_VALUE;
227
228 /* Find TX buffer size, based on the hardware dependent proto. */
229 switch (sc->proto_dlcr6 & FE_D6_TXBSIZ) {
230 case FE_D6_TXBSIZ_2x2KB:
231 sc->txb_size = 2048;
232 break;
233 case FE_D6_TXBSIZ_2x4KB:
234 sc->txb_size = 4096;
235 break;
236 case FE_D6_TXBSIZ_2x8KB:
237 sc->txb_size = 8192;
238 break;
239 default:
240 /* Oops, we can't work with single buffer configuration. */
241 #if FE_DEBUG >= 2
242 log(LOG_WARNING, "%s: strange TXBSIZ config; fixing\n",
243 sc->sc_dev.dv_xname);
244 #endif
245 sc->proto_dlcr6 &= ~FE_D6_TXBSIZ;
246 sc->proto_dlcr6 |= FE_D6_TXBSIZ_2x2KB;
247 sc->txb_size = 2048;
248 break;
249 }
250
251 /* Initialize media goo. */
252 ifmedia_init(&sc->sc_media, 0, mb86960_mediachange,
253 mb86960_mediastatus);
254 if (media != NULL) {
255 for (i = 0; i < nmedia; i++)
256 ifmedia_add(&sc->sc_media, media[i], 0, NULL);
257 ifmedia_set(&sc->sc_media, defmedia);
258 } else {
259 ifmedia_add(&sc->sc_media, IFM_ETHER|IFM_MANUAL, 0, NULL);
260 ifmedia_set(&sc->sc_media, IFM_ETHER|IFM_MANUAL);
261 }
262
263 /* Attach the interface. */
264 if_attach(ifp);
265 ether_ifattach(ifp, sc->sc_enaddr);
266
267 #if NRND > 0
268 rnd_attach_source(&sc->rnd_source, sc->sc_dev.dv_xname,
269 RND_TYPE_NET, 0);
270 #endif
271 /* Print additional info when attached. */
272 printf("%s: Ethernet address %s\n", sc->sc_dev.dv_xname,
273 ether_sprintf(sc->sc_enaddr));
274
275 #if FE_DEBUG >= 3
276 {
277 int buf, txb, bbw, sbw, ram;
278
279 buf = txb = bbw = sbw = ram = -1;
280 switch (sc->proto_dlcr6 & FE_D6_BUFSIZ) {
281 case FE_D6_BUFSIZ_8KB:
282 buf = 8;
283 break;
284 case FE_D6_BUFSIZ_16KB:
285 buf = 16;
286 break;
287 case FE_D6_BUFSIZ_32KB:
288 buf = 32;
289 break;
290 case FE_D6_BUFSIZ_64KB:
291 buf = 64;
292 break;
293 }
294 switch (sc->proto_dlcr6 & FE_D6_TXBSIZ) {
295 case FE_D6_TXBSIZ_2x2KB:
296 txb = 2;
297 break;
298 case FE_D6_TXBSIZ_2x4KB:
299 txb = 4;
300 break;
301 case FE_D6_TXBSIZ_2x8KB:
302 txb = 8;
303 break;
304 }
305 switch (sc->proto_dlcr6 & FE_D6_BBW) {
306 case FE_D6_BBW_BYTE:
307 bbw = 8;
308 break;
309 case FE_D6_BBW_WORD:
310 bbw = 16;
311 break;
312 }
313 switch (sc->proto_dlcr6 & FE_D6_SBW) {
314 case FE_D6_SBW_BYTE:
315 sbw = 8;
316 break;
317 case FE_D6_SBW_WORD:
318 sbw = 16;
319 break;
320 }
321 switch (sc->proto_dlcr6 & FE_D6_SRAM) {
322 case FE_D6_SRAM_100ns:
323 ram = 100;
324 break;
325 case FE_D6_SRAM_150ns:
326 ram = 150;
327 break;
328 }
329 printf("%s: SRAM %dKB %dbit %dns, TXB %dKBx2, %dbit I/O\n",
330 sc->sc_dev.dv_xname, buf, bbw, ram, txb, sbw);
331 }
332 #endif
333
334 /* The attach is successful. */
335 sc->sc_stat |= FE_STAT_ATTACHED;
336 }
337
338 /*
339 * Media change callback.
340 */
341 int
342 mb86960_mediachange(ifp)
343 struct ifnet *ifp;
344 {
345 struct mb86960_softc *sc = ifp->if_softc;
346
347 if (sc->sc_mediachange)
348 return ((*sc->sc_mediachange)(sc));
349 return (0);
350 }
351
352 /*
353 * Media status callback.
354 */
355 void
356 mb86960_mediastatus(ifp, ifmr)
357 struct ifnet *ifp;
358 struct ifmediareq *ifmr;
359 {
360 struct mb86960_softc *sc = ifp->if_softc;
361
362 if ((sc->sc_stat & FE_STAT_ENABLED) == 0) {
363 ifmr->ifm_active = IFM_ETHER | IFM_NONE;
364 ifmr->ifm_status = 0;
365 return;
366 }
367
368 if (sc->sc_mediastatus)
369 (*sc->sc_mediastatus)(sc, ifmr);
370 }
371
372 /*
373 * Reset interface.
374 */
375 void
376 mb86960_reset(sc)
377 struct mb86960_softc *sc;
378 {
379 int s;
380
381 s = splnet();
382 mb86960_stop(sc);
383 mb86960_init(sc);
384 splx(s);
385 }
386
387 /*
388 * Stop everything on the interface.
389 *
390 * All buffered packets, both transmitting and receiving,
391 * if any, will be lost by stopping the interface.
392 */
393 void
394 mb86960_stop(sc)
395 struct mb86960_softc *sc;
396 {
397 bus_space_tag_t bst = sc->sc_bst;
398 bus_space_handle_t bsh = sc->sc_bsh;
399
400 #if FE_DEBUG >= 3
401 log(LOG_INFO, "%s: top of mb86960_stop()\n", sc->sc_dev.dv_xname);
402 mb86960_dump(LOG_INFO, sc);
403 #endif
404
405 /* Disable interrupts. */
406 bus_space_write_1(bst, bsh, FE_DLCR2, 0x00);
407 bus_space_write_1(bst, bsh, FE_DLCR3, 0x00);
408
409 /* Stop interface hardware. */
410 delay(200);
411 bus_space_write_1(bst, bsh, FE_DLCR6,
412 sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
413 delay(200);
414
415 /* Clear all interrupt status. */
416 bus_space_write_1(bst, bsh, FE_DLCR0, 0xFF);
417 bus_space_write_1(bst, bsh, FE_DLCR1, 0xFF);
418
419 /* Put the chip in stand-by mode. */
420 delay(200);
421 bus_space_write_1(bst, bsh, FE_DLCR7,
422 sc->proto_dlcr7 | FE_D7_POWER_DOWN);
423 delay(200);
424
425 /* MAR loading can be delayed. */
426 sc->filter_change = 0;
427
428 /* Call a hook. */
429 if (sc->stop_card)
430 (*sc->stop_card)(sc);
431
432 #if FE_DEBUG >= 3
433 log(LOG_INFO, "%s: end of mb86960_stop()\n", sc->sc_dev.dv_xname);
434 mb86960_dump(LOG_INFO, sc);
435 #endif
436 }
437
438 /*
439 * Device timeout/watchdog routine. Entered if the device neglects to
440 * generate an interrupt after a transmit has been started on it.
441 */
442 void
443 mb86960_watchdog(ifp)
444 struct ifnet *ifp;
445 {
446 struct mb86960_softc *sc = ifp->if_softc;
447
448 log(LOG_ERR, "%s: device timeout\n", sc->sc_dev.dv_xname);
449 #if FE_DEBUG >= 3
450 mb86960_dump(LOG_INFO, sc);
451 #endif
452
453 /* Record how many packets are lost by this accident. */
454 sc->sc_ec.ec_if.if_oerrors += sc->txb_sched + sc->txb_count;
455
456 mb86960_reset(sc);
457 }
458
459 /*
460 * Drop (skip) a packet from receive buffer in 86960 memory.
461 */
462 static __inline__ void
463 mb86960_droppacket(sc)
464 struct mb86960_softc *sc;
465 {
466 bus_space_tag_t bst = sc->sc_bst;
467 bus_space_handle_t bsh = sc->sc_bsh;
468
469 bus_space_write_1(bst, bsh, FE_BMPR14, FE_B14_FILTER | FE_B14_SKIP);
470 }
471
472 /*
473 * Initialize device.
474 */
475 void
476 mb86960_init(sc)
477 struct mb86960_softc *sc;
478 {
479 bus_space_tag_t bst = sc->sc_bst;
480 bus_space_handle_t bsh = sc->sc_bsh;
481 struct ifnet *ifp = &sc->sc_ec.ec_if;
482 int i;
483
484 #if FE_DEBUG >= 3
485 log(LOG_INFO, "%s: top of mb86960_init()\n", sc->sc_dev.dv_xname);
486 mb86960_dump(LOG_INFO, sc);
487 #endif
488
489 /* Reset transmitter flags. */
490 ifp->if_flags &= ~IFF_OACTIVE;
491 ifp->if_timer = 0;
492
493 sc->txb_free = sc->txb_size;
494 sc->txb_count = 0;
495 sc->txb_sched = 0;
496
497 /* Do any card-specific initialization, if applicable. */
498 if (sc->init_card)
499 (*sc->init_card)(sc);
500
501 #if FE_DEBUG >= 3
502 log(LOG_INFO, "%s: after init hook\n", sc->sc_dev.dv_xname);
503 mb86960_dump(LOG_INFO, sc);
504 #endif
505
506 /*
507 * Make sure to disable the chip, also.
508 * This may also help re-programming the chip after
509 * hot insertion of PCMCIAs.
510 */
511 bus_space_write_1(bst, bsh, FE_DLCR6,
512 sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
513 delay(200);
514
515 /* Power up the chip and select register bank for DLCRs. */
516 bus_space_write_1(bst, bsh, FE_DLCR7,
517 sc->proto_dlcr7 | FE_D7_RBS_DLCR | FE_D7_POWER_UP);
518 delay(200);
519
520 /* Feed the station address. */
521 bus_space_write_region_1(bst, bsh, FE_DLCR8,
522 sc->sc_enaddr, ETHER_ADDR_LEN);
523
524 /* Select the BMPR bank for runtime register access. */
525 bus_space_write_1(bst, bsh, FE_DLCR7,
526 sc->proto_dlcr7 | FE_D7_RBS_BMPR | FE_D7_POWER_UP);
527
528 /* Initialize registers. */
529 bus_space_write_1(bst, bsh, FE_DLCR0, 0xFF); /* Clear all bits. */
530 bus_space_write_1(bst, bsh, FE_DLCR1, 0xFF); /* ditto. */
531 bus_space_write_1(bst, bsh, FE_DLCR2, 0x00);
532 bus_space_write_1(bst, bsh, FE_DLCR3, 0x00);
533 bus_space_write_1(bst, bsh, FE_DLCR4, sc->proto_dlcr4);
534 bus_space_write_1(bst, bsh, FE_DLCR5, sc->proto_dlcr5);
535 bus_space_write_1(bst, bsh, FE_BMPR10, 0x00);
536 bus_space_write_1(bst, bsh, FE_BMPR11, FE_B11_CTRL_SKIP);
537 bus_space_write_1(bst, bsh, FE_BMPR12, 0x00);
538 bus_space_write_1(bst, bsh, FE_BMPR13, sc->proto_bmpr13);
539 bus_space_write_1(bst, bsh, FE_BMPR14, FE_B14_FILTER);
540 bus_space_write_1(bst, bsh, FE_BMPR15, 0x00);
541
542 #if FE_DEBUG >= 3
543 log(LOG_INFO, "%s: just before enabling DLC\n", sc->sc_dev.dv_xname);
544 mb86960_dump(LOG_INFO, sc);
545 #endif
546
547 /* Enable interrupts. */
548 bus_space_write_1(bst, bsh, FE_DLCR2, FE_TMASK);
549 bus_space_write_1(bst, bsh, FE_DLCR3, FE_RMASK);
550
551 /* Enable transmitter and receiver. */
552 delay(200);
553 bus_space_write_1(bst, bsh, FE_DLCR6,
554 sc->proto_dlcr6 | FE_D6_DLC_ENABLE);
555 delay(200);
556
557 #if FE_DEBUG >= 3
558 log(LOG_INFO, "%s: just after enabling DLC\n", sc->sc_dev.dv_xname);
559 mb86960_dump(LOG_INFO, sc);
560 #endif
561
562 /*
563 * Make sure to empty the receive buffer.
564 *
565 * This may be redundant, but *if* the receive buffer were full
566 * at this point, the driver would hang. I have experienced
567 * some strange hangups just after UP. I hope the following
568 * code solve the problem.
569 *
570 * I have changed the order of hardware initialization.
571 * I think the receive buffer cannot have any packets at this
572 * point in this version. The following code *must* be
573 * redundant now. FIXME.
574 */
575 for (i = 0; i < FE_MAX_RECV_COUNT; i++) {
576 if (bus_space_read_1(bst, bsh, FE_DLCR5) & FE_D5_BUFEMP)
577 break;
578 mb86960_droppacket(sc);
579 }
580 #if FE_DEBUG >= 1
581 if (i >= FE_MAX_RECV_COUNT)
582 log(LOG_ERR, "%s: cannot empty receive buffer\n",
583 sc->sc_dev.dv_xname);
584 #endif
585 #if FE_DEBUG >= 3
586 if (i < FE_MAX_RECV_COUNT)
587 log(LOG_INFO, "%s: receive buffer emptied (%d)\n",
588 sc->sc_dev.dv_xname, i);
589 #endif
590
591 #if FE_DEBUG >= 3
592 log(LOG_INFO, "%s: after ERB loop\n", sc->sc_dev.dv_xname);
593 mb86960_dump(LOG_INFO, sc);
594 #endif
595
596 /* Do we need this here? */
597 bus_space_write_1(bst, bsh, FE_DLCR0, 0xFF); /* Clear all bits. */
598 bus_space_write_1(bst, bsh, FE_DLCR1, 0xFF); /* ditto. */
599
600 #if FE_DEBUG >= 3
601 log(LOG_INFO, "%s: after FIXME\n", sc->sc_dev.dv_xname);
602 mb86960_dump(LOG_INFO, sc);
603 #endif
604
605 /* Set 'running' flag. */
606 ifp->if_flags |= IFF_RUNNING;
607
608 /*
609 * At this point, the interface is runnung properly,
610 * except that it receives *no* packets. we then call
611 * mb86960_setmode() to tell the chip what packets to be
612 * received, based on the if_flags and multicast group
613 * list. It completes the initialization process.
614 */
615 mb86960_setmode(sc);
616
617 #if FE_DEBUG >= 3
618 log(LOG_INFO, "%s: after setmode\n", sc->sc_dev.dv_xname);
619 mb86960_dump(LOG_INFO, sc);
620 #endif
621
622 /* ...and attempt to start output. */
623 mb86960_start(ifp);
624
625 #if FE_DEBUG >= 3
626 log(LOG_INFO, "%s: end of mb86960_init()\n", sc->sc_dev.dv_xname);
627 mb86960_dump(LOG_INFO, sc);
628 #endif
629 }
630
631 /*
632 * This routine actually starts the transmission on the interface
633 */
634 static __inline__ void
635 mb86960_xmit(sc)
636 struct mb86960_softc *sc;
637 {
638 bus_space_tag_t bst = sc->sc_bst;
639 bus_space_handle_t bsh = sc->sc_bsh;
640
641 /*
642 * Set a timer just in case we never hear from the board again.
643 * We use longer timeout for multiple packet transmission.
644 * I'm not sure this timer value is appropriate. FIXME.
645 */
646 sc->sc_ec.ec_if.if_timer = 1 + sc->txb_count;
647
648 /* Update txb variables. */
649 sc->txb_sched = sc->txb_count;
650 sc->txb_count = 0;
651 sc->txb_free = sc->txb_size;
652
653 #if FE_DELAYED_PADDING
654 /* Omit the postponed padding process. */
655 sc->txb_padding = 0;
656 #endif
657
658 /* Start transmitter, passing packets in TX buffer. */
659 bus_space_write_1(bst, bsh, FE_BMPR10, sc->txb_sched | FE_B10_START);
660 }
661
662 /*
663 * Start output on interface.
664 * We make two assumptions here:
665 * 1) that the current priority is set to splnet _before_ this code
666 * is called *and* is returned to the appropriate priority after
667 * return
668 * 2) that the IFF_OACTIVE flag is checked before this code is called
669 * (i.e. that the output part of the interface is idle)
670 */
671 void
672 mb86960_start(ifp)
673 struct ifnet *ifp;
674 {
675 struct mb86960_softc *sc = ifp->if_softc;
676 struct mbuf *m;
677
678 #if FE_DEBUG >= 1
679 /* Just a sanity check. */
680 if ((sc->txb_count == 0) != (sc->txb_free == sc->txb_size)) {
681 /*
682 * Txb_count and txb_free co-works to manage the
683 * transmission buffer. Txb_count keeps track of the
684 * used potion of the buffer, while txb_free does unused
685 * potion. So, as long as the driver runs properly,
686 * txb_count is zero if and only if txb_free is same
687 * as txb_size (which represents whole buffer.)
688 */
689 log(LOG_ERR, "%s: inconsistent txb variables (%d, %d)\n",
690 sc->sc_dev.dv_xname, sc->txb_count, sc->txb_free);
691 /*
692 * So, what should I do, then?
693 *
694 * We now know txb_count and txb_free contradicts. We
695 * cannot, however, tell which is wrong. More
696 * over, we cannot peek 86960 transmission buffer or
697 * reset the transmission buffer. (In fact, we can
698 * reset the entire interface. I don't want to do it.)
699 *
700 * If txb_count is incorrect, leaving it as is will cause
701 * sending of gabages after next interrupt. We have to
702 * avoid it. Hence, we reset the txb_count here. If
703 * txb_free was incorrect, resetting txb_count just loose
704 * some packets. We can live with it.
705 */
706 sc->txb_count = 0;
707 }
708 #endif
709
710 #if FE_DEBUG >= 1
711 /*
712 * First, see if there are buffered packets and an idle
713 * transmitter - should never happen at this point.
714 */
715 if ((sc->txb_count > 0) && (sc->txb_sched == 0)) {
716 log(LOG_ERR, "%s: transmitter idle with %d buffered packets\n",
717 sc->sc_dev.dv_xname, sc->txb_count);
718 mb86960_xmit(sc);
719 }
720 #endif
721
722 /*
723 * Stop accepting more transmission packets temporarily, when
724 * a filter change request is delayed. Updating the MARs on
725 * 86960 flushes the transmisstion buffer, so it is delayed
726 * until all buffered transmission packets have been sent
727 * out.
728 */
729 if (sc->filter_change) {
730 /*
731 * Filter change request is delayed only when the DLC is
732 * working. DLC soon raise an interrupt after finishing
733 * the work.
734 */
735 goto indicate_active;
736 }
737
738 for (;;) {
739 /*
740 * See if there is room to put another packet in the buffer.
741 * We *could* do better job by peeking the send queue to
742 * know the length of the next packet. Current version just
743 * tests against the worst case (i.e., longest packet). FIXME.
744 *
745 * When adding the packet-peek feature, don't forget adding a
746 * test on txb_count against QUEUEING_MAX.
747 * There is a little chance the packet count exceeds
748 * the limit. Assume transmission buffer is 8KB (2x8KB
749 * configuration) and an application sends a bunch of small
750 * (i.e., minimum packet sized) packets rapidly. An 8KB
751 * buffer can hold 130 blocks of 62 bytes long...
752 */
753 if (sc->txb_free <
754 (ETHER_MAX_LEN - ETHER_CRC_LEN) + FE_TXLEN_SIZE) {
755 /* No room. */
756 goto indicate_active;
757 }
758
759 #if FE_SINGLE_TRANSMISSION
760 if (sc->txb_count > 0) {
761 /* Just one packet per a transmission buffer. */
762 goto indicate_active;
763 }
764 #endif
765
766 /*
767 * Get the next mbuf chain for a packet to send.
768 */
769 IFQ_DEQUEUE(&ifp->if_snd, m);
770 if (m == 0) {
771 /* No more packets to send. */
772 goto indicate_inactive;
773 }
774
775 #if NBPFILTER > 0
776 /* Tap off here if there is a BPF listener. */
777 if (ifp->if_bpf)
778 bpf_mtap(ifp->if_bpf, m);
779 #endif
780
781 /*
782 * Copy the mbuf chain into the transmission buffer.
783 * txb_* variables are updated as necessary.
784 */
785 mb86960_write_mbufs(sc, m);
786
787 m_freem(m);
788
789 /* Start transmitter if it's idle. */
790 if (sc->txb_sched == 0)
791 mb86960_xmit(sc);
792 }
793
794 indicate_inactive:
795 /*
796 * We are using the !OACTIVE flag to indicate to
797 * the outside world that we can accept an
798 * additional packet rather than that the
799 * transmitter is _actually_ active. Indeed, the
800 * transmitter may be active, but if we haven't
801 * filled all the buffers with data then we still
802 * want to accept more.
803 */
804 ifp->if_flags &= ~IFF_OACTIVE;
805 return;
806
807 indicate_active:
808 /*
809 * The transmitter is active, and there are no room for
810 * more outgoing packets in the transmission buffer.
811 */
812 ifp->if_flags |= IFF_OACTIVE;
813 return;
814 }
815
816 /*
817 * Transmission interrupt handler
818 * The control flow of this function looks silly. FIXME.
819 */
820 void
821 mb86960_tint(sc, tstat)
822 struct mb86960_softc *sc;
823 u_int8_t tstat;
824 {
825 bus_space_tag_t bst = sc->sc_bst;
826 bus_space_handle_t bsh = sc->sc_bsh;
827 struct ifnet *ifp = &sc->sc_ec.ec_if;
828 int left;
829 int col;
830
831 /*
832 * Handle "excessive collision" interrupt.
833 */
834 if (tstat & FE_D0_COLL16) {
835 /*
836 * Find how many packets (including this collided one)
837 * are left unsent in transmission buffer.
838 */
839 left = bus_space_read_1(bst, bsh, FE_BMPR10);
840
841 #if FE_DEBUG >= 2
842 log(LOG_WARNING, "%s: excessive collision (%d/%d)\n",
843 sc->sc_dev.dv_xname, left, sc->txb_sched);
844 #endif
845 #if FE_DEBUG >= 3
846 mb86960_dump(LOG_INFO, sc);
847 #endif
848
849 /*
850 * Update statistics.
851 */
852 ifp->if_collisions += 16;
853 ifp->if_oerrors++;
854 ifp->if_opackets += sc->txb_sched - left;
855
856 /*
857 * Collision statistics has been updated.
858 * Clear the collision flag on 86960 now to avoid confusion.
859 */
860 bus_space_write_1(bst, bsh, FE_DLCR0, FE_D0_COLLID);
861
862 /*
863 * Restart transmitter, skipping the
864 * collided packet.
865 *
866 * We *must* skip the packet to keep network running
867 * properly. Excessive collision error is an
868 * indication of the network overload. If we
869 * tried sending the same packet after excessive
870 * collision, the network would be filled with
871 * out-of-time packets. Packets belonging
872 * to reliable transport (such as TCP) are resent
873 * by some upper layer.
874 */
875 bus_space_write_1(bst, bsh, FE_BMPR11,
876 FE_B11_CTRL_SKIP | FE_B11_MODE1);
877 sc->txb_sched = left - 1;
878 }
879
880 /*
881 * Handle "transmission complete" interrupt.
882 */
883 if (tstat & FE_D0_TXDONE) {
884 /*
885 * Add in total number of collisions on last
886 * transmission. We also clear "collision occurred" flag
887 * here.
888 *
889 * 86960 has a design flow on collision count on multiple
890 * packet transmission. When we send two or more packets
891 * with one start command (that's what we do when the
892 * transmission queue is clauded), 86960 informs us number
893 * of collisions occurred on the last packet on the
894 * transmission only. Number of collisions on previous
895 * packets are lost. I have told that the fact is clearly
896 * stated in the Fujitsu document.
897 *
898 * I considered not to mind it seriously. Collision
899 * count is not so important, anyway. Any comments? FIXME.
900 */
901
902 if (bus_space_read_1(bst, bsh, FE_DLCR0) & FE_D0_COLLID) {
903 /* Clear collision flag. */
904 bus_space_write_1(bst, bsh, FE_DLCR0, FE_D0_COLLID);
905
906 /* Extract collision count from 86960. */
907 col = bus_space_read_1(bst, bsh, FE_DLCR4) & FE_D4_COL;
908 if (col == 0) {
909 /*
910 * Status register indicates collisions,
911 * while the collision count is zero.
912 * This can happen after multiple packet
913 * transmission, indicating that one or more
914 * previous packet(s) had been collided.
915 *
916 * Since the accurate number of collisions
917 * has been lost, we just guess it as 1;
918 * Am I too optimistic? FIXME.
919 */
920 col = 1;
921 } else
922 col >>= FE_D4_COL_SHIFT;
923 ifp->if_collisions += col;
924 #if FE_DEBUG >= 4
925 log(LOG_WARNING, "%s: %d collision%s (%d)\n",
926 sc->sc_dev.dv_xname, col, col == 1 ? "" : "s",
927 sc->txb_sched);
928 #endif
929 }
930
931 /*
932 * Update total number of successfully
933 * transmitted packets.
934 */
935 ifp->if_opackets += sc->txb_sched;
936 sc->txb_sched = 0;
937 }
938
939 if (sc->txb_sched == 0) {
940 /*
941 * The transmitter is no more active.
942 * Reset output active flag and watchdog timer.
943 */
944 ifp->if_flags &= ~IFF_OACTIVE;
945 ifp->if_timer = 0;
946
947 /*
948 * If more data is ready to transmit in the buffer, start
949 * transmitting them. Otherwise keep transmitter idle,
950 * even if more data is queued. This gives receive
951 * process a slight priority.
952 */
953 if (sc->txb_count > 0)
954 mb86960_xmit(sc);
955 }
956 }
957
958 /*
959 * Ethernet interface receiver interrupt.
960 */
961 void
962 mb86960_rint(sc, rstat)
963 struct mb86960_softc *sc;
964 u_int8_t rstat;
965 {
966 bus_space_tag_t bst = sc->sc_bst;
967 bus_space_handle_t bsh = sc->sc_bsh;
968 struct ifnet *ifp = &sc->sc_ec.ec_if;
969 u_int status, len;
970 int i;
971
972 /*
973 * Update statistics if this interrupt is caused by an error.
974 */
975 if (rstat & (FE_D1_OVRFLO | FE_D1_CRCERR | FE_D1_ALGERR |
976 FE_D1_SRTPKT)) {
977 #if FE_DEBUG >= 3
978 char sbuf[sizeof(FE_D1_ERRBITS) + 64];
979
980 bitmask_snprintf(rstat, FE_D1_ERRBITS, sbuf, sizeof(sbuf));
981 log(LOG_WARNING, "%s: receive error: %s\n",
982 sc->sc_dev.dv_xname, sbuf);
983 #endif
984 ifp->if_ierrors++;
985 }
986
987 /*
988 * MB86960 has a flag indicating "receive queue empty."
989 * We just loop checking the flag to pull out all received
990 * packets.
991 *
992 * We limit the number of iterrations to avoid infinite loop.
993 * It can be caused by a very slow CPU (some broken
994 * peripheral may insert incredible number of wait cycles)
995 * or, worse, by a broken MB86960 chip.
996 */
997 for (i = 0; i < FE_MAX_RECV_COUNT; i++) {
998 /* Stop the iterration if 86960 indicates no packets. */
999 if (bus_space_read_1(bst, bsh, FE_DLCR5) & FE_D5_BUFEMP)
1000 break;
1001
1002 /*
1003 * Extract receive packet status from the receive
1004 * packet header.
1005 */
1006 if (sc->sc_flags & FE_FLAGS_SBW_BYTE) {
1007 status = bus_space_read_1(bst, bsh, FE_BMPR8);
1008 (void)bus_space_read_1(bst, bsh, FE_BMPR8);
1009 } else
1010 status = bus_space_read_2(bst, bsh, FE_BMPR8);
1011
1012 #if FE_DEBUG >= 4
1013 log(LOG_INFO, "%s: receive status = %02x\n",
1014 sc->sc_dev.dv_xname, status);
1015 #endif
1016
1017 /*
1018 * If there was an error, update statistics and drop
1019 * the packet, unless the interface is in promiscuous
1020 * mode.
1021 */
1022 if ((status & FE_RXSTAT_GOODPKT) == 0) {
1023 if ((ifp->if_flags & IFF_PROMISC) == 0) {
1024 ifp->if_ierrors++;
1025 mb86960_droppacket(sc);
1026 continue;
1027 }
1028 }
1029
1030 /*
1031 * Extract the packet length from the receive packet header.
1032 * It is a sum of a header (14 bytes) and a payload.
1033 * CRC has been stripped off by the 86960.
1034 */
1035 if (sc->sc_flags & FE_FLAGS_SBW_BYTE) {
1036 len = bus_space_read_1(bst, bsh, FE_BMPR8);
1037 len |= bus_space_read_1(bst, bsh, FE_BMPR8) << 8;
1038 } else
1039 len = bus_space_read_2(bst, bsh, FE_BMPR8);
1040
1041 /*
1042 * MB86965 checks the packet length and drop big packet
1043 * before passing it to us. There are no chance we can
1044 * get [crufty] packets. Hence, if the length exceeds
1045 * the specified limit, it means some serious failure,
1046 * such as out-of-sync on receive buffer management.
1047 *
1048 * Is this statement true? FIXME.
1049 */
1050 if (len > (ETHER_MAX_LEN - ETHER_CRC_LEN) ||
1051 len < ETHER_HDR_LEN) {
1052 #if FE_DEBUG >= 2
1053 log(LOG_WARNING,
1054 "%s: received a %s packet? (%u bytes)\n",
1055 sc->sc_dev.dv_xname,
1056 len < ETHER_HDR_LEN ? "partial" : "big", len);
1057 #endif
1058 ifp->if_ierrors++;
1059 mb86960_droppacket(sc);
1060 continue;
1061 }
1062
1063 /*
1064 * Check for a short (RUNT) packet. We *do* check
1065 * but do nothing other than print a message.
1066 * Short packets are illegal, but does nothing bad
1067 * if it carries data for upper layer.
1068 */
1069 #if FE_DEBUG >= 2
1070 if (len < (ETHER_MIN_LEN - ETHER_CRC_LEN)) {
1071 log(LOG_WARNING,
1072 "%s: received a short packet? (%u bytes)\n",
1073 sc->sc_dev.dv_xname, len);
1074 }
1075 #endif
1076
1077 /*
1078 * Go get a packet.
1079 */
1080 if (mb86960_get_packet(sc, len) == 0) {
1081 /* Skip a packet, updating statistics. */
1082 #if FE_DEBUG >= 2
1083 log(LOG_WARNING,
1084 "%s: out of mbufs; dropping packet (%u bytes)\n",
1085 sc->sc_dev.dv_xname, len);
1086 #endif
1087 ifp->if_ierrors++;
1088 mb86960_droppacket(sc);
1089
1090 /*
1091 * We stop receiving packets, even if there are
1092 * more in the buffer. We hope we can get more
1093 * mbufs next time.
1094 */
1095 return;
1096 }
1097
1098 /* Successfully received a packet. Update stat. */
1099 ifp->if_ipackets++;
1100 }
1101 }
1102
1103 /*
1104 * Ethernet interface interrupt processor
1105 */
1106 int
1107 mb86960_intr(arg)
1108 void *arg;
1109 {
1110 struct mb86960_softc *sc = arg;
1111 bus_space_tag_t bst = sc->sc_bst;
1112 bus_space_handle_t bsh = sc->sc_bsh;
1113 struct ifnet *ifp = &sc->sc_ec.ec_if;
1114 u_int8_t tstat, rstat;
1115
1116 if ((sc->sc_stat & FE_STAT_ENABLED) == 0 ||
1117 (sc->sc_dev.dv_flags & DVF_ACTIVE) == 0)
1118 return (0);
1119
1120 #if FE_DEBUG >= 4
1121 log(LOG_INFO, "%s: mb86960_intr()\n", sc->sc_dev.dv_xname);
1122 mb86960_dump(LOG_INFO, sc);
1123 #endif
1124
1125 /*
1126 * Get interrupt conditions, masking unneeded flags.
1127 */
1128 tstat = bus_space_read_1(bst, bsh, FE_DLCR0) & FE_TMASK;
1129 rstat = bus_space_read_1(bst, bsh, FE_DLCR1) & FE_RMASK;
1130 if (tstat == 0 && rstat == 0)
1131 return (0);
1132
1133 /*
1134 * Loop until there are no more new interrupt conditions.
1135 */
1136 for (;;) {
1137 /*
1138 * Reset the conditions we are acknowledging.
1139 */
1140 bus_space_write_1(bst, bsh, FE_DLCR0, tstat);
1141 bus_space_write_1(bst, bsh, FE_DLCR1, rstat);
1142
1143 /*
1144 * Handle transmitter interrupts. Handle these first because
1145 * the receiver will reset the board under some conditions.
1146 */
1147 if (tstat != 0)
1148 mb86960_tint(sc, tstat);
1149
1150 /*
1151 * Handle receiver interrupts.
1152 */
1153 if (rstat != 0)
1154 mb86960_rint(sc, rstat);
1155
1156 /*
1157 * Update the multicast address filter if it is
1158 * needed and possible. We do it now, because
1159 * we can make sure the transmission buffer is empty,
1160 * and there is a good chance that the receive queue
1161 * is empty. It will minimize the possibility of
1162 * packet lossage.
1163 */
1164 if (sc->filter_change &&
1165 sc->txb_count == 0 && sc->txb_sched == 0) {
1166 mb86960_loadmar(sc);
1167 ifp->if_flags &= ~IFF_OACTIVE;
1168 }
1169
1170 /*
1171 * If it looks like the transmitter can take more data,
1172 * attempt to start output on the interface. This is done
1173 * after handling the receiver interrupt to give the
1174 * receive operation priority.
1175 */
1176 if ((ifp->if_flags & IFF_OACTIVE) == 0)
1177 mb86960_start(ifp);
1178
1179 #if NRND > 0
1180 if (rstat != 0 || tstat != 0)
1181 rnd_add_uint32(&sc->rnd_source, rstat + tstat);
1182 #endif
1183
1184 /*
1185 * Get interrupt conditions, masking unneeded flags.
1186 */
1187 tstat = bus_space_read_1(bst, bsh, FE_DLCR0) & FE_TMASK;
1188 rstat = bus_space_read_1(bst, bsh, FE_DLCR1) & FE_RMASK;
1189 if (tstat == 0 && rstat == 0)
1190 return (1);
1191 }
1192 }
1193
1194 /*
1195 * Process an ioctl request. This code needs some work - it looks pretty ugly.
1196 */
1197 int
1198 mb86960_ioctl(ifp, cmd, data)
1199 struct ifnet *ifp;
1200 u_long cmd;
1201 caddr_t data;
1202 {
1203 struct mb86960_softc *sc = ifp->if_softc;
1204 struct ifaddr *ifa = (struct ifaddr *)data;
1205 struct ifreq *ifr = (struct ifreq *)data;
1206 int s, error = 0;
1207
1208 #if FE_DEBUG >= 3
1209 log(LOG_INFO, "%s: ioctl(%lx)\n", sc->sc_dev.dv_xname, cmd);
1210 #endif
1211
1212 s = splnet();
1213
1214 switch (cmd) {
1215 case SIOCSIFADDR:
1216 if ((error = mb86960_enable(sc)) != 0)
1217 break;
1218 ifp->if_flags |= IFF_UP;
1219
1220 switch (ifa->ifa_addr->sa_family) {
1221 #ifdef INET
1222 case AF_INET:
1223 mb86960_init(sc);
1224 arp_ifinit(ifp, ifa);
1225 break;
1226 #endif
1227 #ifdef NS
1228 case AF_NS:
1229 {
1230 struct ns_addr *ina = &IA_SNS(ifa)->sns_addr;
1231
1232 if (ns_nullhost(*ina))
1233 ina->x_host =
1234 *(union ns_host *)LLADDR(ifp->if_sadl);
1235 else {
1236 memcpy(LLADDR(ifp->if_sadl),
1237 ina->x_host.c_host, ETHER_ADDR_LEN);
1238 }
1239 /* Set new address. */
1240 mb86960_init(sc);
1241 break;
1242 }
1243 #endif
1244 default:
1245 mb86960_init(sc);
1246 break;
1247 }
1248 break;
1249
1250 case SIOCSIFFLAGS:
1251 if ((ifp->if_flags & IFF_UP) == 0 &&
1252 (ifp->if_flags & IFF_RUNNING) != 0) {
1253 /*
1254 * If interface is marked down and it is running, then
1255 * stop it.
1256 */
1257 mb86960_stop(sc);
1258 ifp->if_flags &= ~IFF_RUNNING;
1259 mb86960_disable(sc);
1260 } else if ((ifp->if_flags & IFF_UP) != 0 &&
1261 (ifp->if_flags & IFF_RUNNING) == 0) {
1262 /*
1263 * If interface is marked up and it is stopped, then
1264 * start it.
1265 */
1266 if ((error = mb86960_enable(sc)) != 0)
1267 break;
1268 mb86960_init(sc);
1269 } else if ((ifp->if_flags & IFF_UP) != 0) {
1270 /*
1271 * Reset the interface to pick up changes in any other
1272 * flags that affect hardware registers.
1273 */
1274 mb86960_setmode(sc);
1275 }
1276 #if FE_DEBUG >= 1
1277 /* "ifconfig fe0 debug" to print register dump. */
1278 if (ifp->if_flags & IFF_DEBUG) {
1279 log(LOG_INFO, "%s: SIOCSIFFLAGS(DEBUG)\n",
1280 sc->sc_dev.dv_xname);
1281 mb86960_dump(LOG_DEBUG, sc);
1282 }
1283 #endif
1284 break;
1285
1286 case SIOCADDMULTI:
1287 case SIOCDELMULTI:
1288 if ((sc->sc_stat & FE_STAT_ENABLED) == 0) {
1289 error = EIO;
1290 break;
1291 }
1292
1293 /* Update our multicast list. */
1294 error = (cmd == SIOCADDMULTI) ?
1295 ether_addmulti(ifr, &sc->sc_ec) :
1296 ether_delmulti(ifr, &sc->sc_ec);
1297
1298 if (error == ENETRESET) {
1299 /*
1300 * Multicast list has changed; set the hardware filter
1301 * accordingly.
1302 */
1303 mb86960_setmode(sc);
1304 error = 0;
1305 }
1306 break;
1307
1308 case SIOCGIFMEDIA:
1309 case SIOCSIFMEDIA:
1310 error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
1311 break;
1312
1313 default:
1314 error = EINVAL;
1315 break;
1316 }
1317
1318 splx(s);
1319 return (error);
1320 }
1321
1322 /*
1323 * Retrieve packet from receive buffer and send to the next level up via
1324 * ether_input(). If there is a BPF listener, give a copy to BPF, too.
1325 * Returns 0 if success, -1 if error (i.e., mbuf allocation failure).
1326 */
1327 int
1328 mb86960_get_packet(sc, len)
1329 struct mb86960_softc *sc;
1330 u_int len;
1331 {
1332 bus_space_tag_t bst = sc->sc_bst;
1333 bus_space_handle_t bsh = sc->sc_bsh;
1334 struct ifnet *ifp = &sc->sc_ec.ec_if;
1335 struct mbuf *m;
1336
1337 /* Allocate a header mbuf. */
1338 MGETHDR(m, M_DONTWAIT, MT_DATA);
1339 if (m == 0)
1340 return (0);
1341 m->m_pkthdr.rcvif = ifp;
1342 m->m_pkthdr.len = len;
1343
1344 /* The following silliness is to make NFS happy. */
1345 #define EROUND ((sizeof(struct ether_header) + 3) & ~3)
1346 #define EOFF (EROUND - sizeof(struct ether_header))
1347
1348 /*
1349 * Our strategy has one more problem. There is a policy on
1350 * mbuf cluster allocation. It says that we must have at
1351 * least MINCLSIZE (208 bytes) to allocate a cluster. For a
1352 * packet of a size between (MHLEN - 2) to (MINCLSIZE - 2),
1353 * our code violates the rule...
1354 * On the other hand, the current code is short, simple,
1355 * and fast, however. It does no harmful thing, just waists
1356 * some memory. Any comments? FIXME.
1357 */
1358
1359 /* Attach a cluster if this packet doesn't fit in a normal mbuf. */
1360 if (len > MHLEN - EOFF) {
1361 MCLGET(m, M_DONTWAIT);
1362 if ((m->m_flags & M_EXT) == 0) {
1363 m_freem(m);
1364 return (0);
1365 }
1366 }
1367
1368 /*
1369 * The following assumes there is room for the ether header in the
1370 * header mbuf.
1371 */
1372 m->m_data += EOFF;
1373
1374 /* Set the length of this packet. */
1375 m->m_len = len;
1376
1377 /* Get a packet. */
1378 if (sc->sc_flags & FE_FLAGS_SBW_BYTE)
1379 bus_space_read_multi_1(bst, bsh, FE_BMPR8,
1380 mtod(m, u_int8_t *), len);
1381 else
1382 bus_space_read_multi_stream_2(bst, bsh, FE_BMPR8,
1383 mtod(m, u_int16_t *), (len + 1) >> 1);
1384
1385 #if NBPFILTER > 0
1386 /*
1387 * Check if there's a BPF listener on this interface. If so, hand off
1388 * the raw packet to bpf.
1389 */
1390 if (ifp->if_bpf)
1391 bpf_mtap(ifp->if_bpf, m);
1392 #endif
1393
1394 (*ifp->if_input)(ifp, m);
1395 return (1);
1396 }
1397
1398 /*
1399 * Write an mbuf chain to the transmission buffer memory using 16 bit PIO.
1400 * Returns number of bytes actually written, including length word.
1401 *
1402 * If an mbuf chain is too long for an Ethernet frame, it is not sent.
1403 * Packets shorter than Ethernet minimum are legal, and we pad them
1404 * before sending out. An exception is "partial" packets which are
1405 * shorter than mandatory Ethernet header.
1406 *
1407 * I wrote a code for an experimental "delayed padding" technique.
1408 * When employed, it postpones the padding process for short packets.
1409 * If xmit() occurred at the moment, the padding process is omitted, and
1410 * garbages are sent as pad data. If next packet is stored in the
1411 * transmission buffer before xmit(), write_mbuf() pads the previous
1412 * packet before transmitting new packet. This *may* gain the
1413 * system performance (slightly).
1414 */
1415 void
1416 mb86960_write_mbufs(sc, m)
1417 struct mb86960_softc *sc;
1418 struct mbuf *m;
1419 {
1420 bus_space_tag_t bst = sc->sc_bst;
1421 bus_space_handle_t bsh = sc->sc_bsh;
1422 int totlen, len;
1423 #if FE_DEBUG >= 2
1424 struct mbuf *mp;
1425 #endif
1426
1427 #if FE_DELAYED_PADDING
1428 /* Do the "delayed padding." */
1429 if (sc->txb_padding > 0) {
1430 if (sc->sc_flags & FE_FLAGS_SBW_BYTE) {
1431 for (len = sc->txb_padding; len > 0; len--)
1432 bus_space_write_1(bst, bsh, FE_BMPR8, 0);
1433 } else {
1434 for (len = sc->txb_padding >> 1; len > 0; len--)
1435 bus_space_write_2(bst, bsh, FE_BMPR8, 0);
1436 }
1437 sc->txb_padding = 0;
1438 }
1439 #endif
1440
1441 /* We need to use m->m_pkthdr.len, so require the header */
1442 if ((m->m_flags & M_PKTHDR) == 0)
1443 panic("mb86960_write_mbufs: no header mbuf");
1444
1445 #if FE_DEBUG >= 2
1446 /* First, count up the total number of bytes to copy. */
1447 for (totlen = 0, mp = m; mp != 0; mp = mp->m_next)
1448 totlen += mp->m_len;
1449 /* Check if this matches the one in the packet header. */
1450 if (totlen != m->m_pkthdr.len)
1451 log(LOG_WARNING, "%s: packet length mismatch? (%d/%d)\n",
1452 sc->sc_dev.dv_xname, totlen, m->m_pkthdr.len);
1453 #else
1454 /* Just use the length value in the packet header. */
1455 totlen = m->m_pkthdr.len;
1456 #endif
1457
1458 #if FE_DEBUG >= 1
1459 /*
1460 * Should never send big packets. If such a packet is passed,
1461 * it should be a bug of upper layer. We just ignore it.
1462 * ... Partial (too short) packets, neither.
1463 */
1464 if (totlen > (ETHER_MAX_LEN - ETHER_CRC_LEN) ||
1465 totlen < ETHER_HDR_LEN) {
1466 log(LOG_ERR, "%s: got a %s packet (%u bytes) to send\n",
1467 sc->sc_dev.dv_xname,
1468 totlen < ETHER_HDR_LEN ? "partial" : "big", totlen);
1469 sc->sc_ec.ec_if.if_oerrors++;
1470 return;
1471 }
1472 #endif
1473
1474 /*
1475 * Put the length word for this frame.
1476 * Does 86960 accept odd length? -- Yes.
1477 * Do we need to pad the length to minimum size by ourselves?
1478 * -- Generally yes. But for (or will be) the last
1479 * packet in the transmission buffer, we can skip the
1480 * padding process. It may gain performance slightly. FIXME.
1481 */
1482 len = max(totlen, (ETHER_MIN_LEN - ETHER_CRC_LEN));
1483 if (sc->sc_flags & FE_FLAGS_SBW_BYTE) {
1484 bus_space_write_1(bst, bsh, FE_BMPR8, len);
1485 bus_space_write_1(bst, bsh, FE_BMPR8, len >> 8);
1486 } else {
1487 bus_space_write_2(bst, bsh, FE_BMPR8, len);
1488 /* roundup packet length since we will use word access */
1489 totlen = (totlen + 1) & ~1;
1490 }
1491
1492 /*
1493 * Update buffer status now.
1494 * Truncate the length up to an even number
1495 * if the chip is set in SBW_WORD mode.
1496 */
1497 sc->txb_free -= FE_TXLEN_SIZE +
1498 max(totlen, (ETHER_MIN_LEN - ETHER_CRC_LEN));
1499 sc->txb_count++;
1500
1501 #if FE_DELAYED_PADDING
1502 /* Postpone the packet padding if necessary. */
1503 if (totlen < (ETHER_MIN_LEN - ETHER_CRC_LEN))
1504 sc->txb_padding = (ETHER_MIN_LEN - ETHER_CRC_LEN) - totlen;
1505 #endif
1506
1507 /*
1508 * Transfer the data from mbuf chain to the transmission buffer.
1509 * If the MB86960 is configured in word mode, data needs to be
1510 * transferred as words, and only words.
1511 * So that we require some extra code to patch over odd-length
1512 * or unaligned mbufs.
1513 */
1514 if (sc->sc_flags & FE_FLAGS_SBW_BYTE) {
1515 /* It's simple in byte mode. */
1516 for (; m != NULL; m = m->m_next) {
1517 if (m->m_len) {
1518 bus_space_write_multi_1(bst, bsh, FE_BMPR8,
1519 mtod(m, u_int8_t *), m->m_len);
1520 }
1521 }
1522 } else {
1523 /* a bit trickier in word mode. */
1524 u_int8_t *data, savebyte[2];
1525 int leftover;
1526
1527 leftover = 0;
1528 savebyte[0] = savebyte[1] = 0;
1529
1530 for (; m != NULL; m = m->m_next) {
1531 len = m->m_len;
1532 if (len == 0)
1533 continue;
1534 data = mtod(m, u_int8_t *);
1535 while (len > 0) {
1536 if (leftover) {
1537 /*
1538 * Data left over (from mbuf or
1539 * realignment). Buffer the next
1540 * byte, and write it and the
1541 * leftover data out.
1542 */
1543 savebyte[1] = *data++;
1544 len--;
1545 bus_space_write_stream_2(bst, bsh,
1546 FE_BMPR8, *(u_int16_t *)savebyte);
1547 leftover = 0;
1548 } else if (BUS_SPACE_ALIGNED_POINTER(data,
1549 u_int16_t) == 0) {
1550 /*
1551 * Unaligned data; buffer the next byte.
1552 */
1553 savebyte[0] = *data++;
1554 len--;
1555 leftover = 1;
1556 } else {
1557 /*
1558 * Aligned data; output contiguous
1559 * words as much as we can, then
1560 * buffer the remaining byte, if any.
1561 */
1562 leftover = len & 1;
1563 len &= ~1;
1564 bus_space_write_multi_stream_2(bst, bsh,
1565 FE_BMPR8, (u_int16_t *)data,
1566 len >> 1);
1567 data += len;
1568 if (leftover)
1569 savebyte[0] = *data++;
1570 len = 0;
1571 }
1572 }
1573 if (len < 0)
1574 panic("mb86960_write_mbufs: negative len");
1575 }
1576 if (leftover) {
1577 savebyte[1] = 0;
1578 bus_space_write_stream_2(bst, bsh, FE_BMPR8,
1579 *(u_int16_t *)savebyte);
1580 }
1581 }
1582 #if FE_DELAYED_PADDING == 0
1583 /*
1584 * Pad the packet to the minimum length if necessary.
1585 */
1586 len = (ETHER_MIN_LEN - ETHER_CRC_LEN) - totlen;
1587 if (len > 0) {
1588 if (sc->sc_flags & FE_FLAGS_SBW_BYTE) {
1589 while (len-- > 0)
1590 bus_space_write_1(bst, bsh, FE_BMPR8, 0);
1591 } else {
1592 len >>= 1;
1593 while (len-- > 0)
1594 bus_space_write_2(bst, bsh, FE_BMPR8, 0);
1595 }
1596 }
1597 #endif
1598 }
1599
1600 /*
1601 * Compute the multicast address filter from the
1602 * list of multicast addresses we need to listen to.
1603 */
1604 void
1605 mb86960_getmcaf(ec, af)
1606 struct ethercom *ec;
1607 u_int8_t *af;
1608 {
1609 struct ifnet *ifp = &ec->ec_if;
1610 struct ether_multi *enm;
1611 u_int32_t crc;
1612 struct ether_multistep step;
1613
1614 /*
1615 * Set up multicast address filter by passing all multicast addresses
1616 * through a crc generator, and then using the high order 6 bits as an
1617 * index into the 64 bit logical address filter. The high order bit
1618 * selects the word, while the rest of the bits select the bit within
1619 * the word.
1620 */
1621
1622 if ((ifp->if_flags & IFF_PROMISC) != 0)
1623 goto allmulti;
1624
1625 memset(af, 0, FE_FILTER_LEN);
1626 ETHER_FIRST_MULTI(step, ec, enm);
1627 while (enm != NULL) {
1628 if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
1629 sizeof(enm->enm_addrlo)) != 0) {
1630 /*
1631 * We must listen to a range of multicast addresses.
1632 * For now, just accept all multicasts, rather than
1633 * trying to set only those filter bits needed to match
1634 * the range. (At this time, the only use of address
1635 * ranges is for IP multicast routing, for which the
1636 * range is big enough to require all bits set.)
1637 */
1638 goto allmulti;
1639 }
1640
1641 crc = ether_crc32_le(enm->enm_addrlo, ETHER_ADDR_LEN);
1642
1643 /* Just want the 6 most significant bits. */
1644 crc >>= 26;
1645
1646 /* Turn on the corresponding bit in the filter. */
1647 af[crc >> 3] |= 1 << (crc & 7);
1648
1649 ETHER_NEXT_MULTI(step, enm);
1650 }
1651 ifp->if_flags &= ~IFF_ALLMULTI;
1652 return;
1653
1654 allmulti:
1655 ifp->if_flags |= IFF_ALLMULTI;
1656 memset(af, 0xff, FE_FILTER_LEN);
1657 }
1658
1659 /*
1660 * Calculate a new "multicast packet filter" and put the 86960
1661 * receiver in appropriate mode.
1662 */
1663 void
1664 mb86960_setmode(sc)
1665 struct mb86960_softc *sc;
1666 {
1667 bus_space_tag_t bst = sc->sc_bst;
1668 bus_space_handle_t bsh = sc->sc_bsh;
1669 int flags = sc->sc_ec.ec_if.if_flags;
1670
1671 /*
1672 * If the interface is not running, we postpone the update
1673 * process for receive modes and multicast address filter
1674 * until the interface is restarted. It reduces some
1675 * complicated job on maintaining chip states. (Earlier versions
1676 * of this driver had a bug on that point...)
1677 *
1678 * To complete the trick, mb86960_init() calls mb86960_setmode() after
1679 * restarting the interface.
1680 */
1681 if ((flags & IFF_RUNNING) == 0)
1682 return;
1683
1684 /*
1685 * Promiscuous mode is handled separately.
1686 */
1687 if ((flags & IFF_PROMISC) != 0) {
1688 /*
1689 * Program 86960 to receive all packets on the segment
1690 * including those directed to other stations.
1691 * Multicast filter stored in MARs are ignored
1692 * under this setting, so we don't need to update it.
1693 *
1694 * Promiscuous mode is used solely by BPF, and BPF only
1695 * listens to valid (no error) packets. So, we ignore
1696 * errornous ones even in this mode.
1697 */
1698 bus_space_write_1(bst, bsh, FE_DLCR5,
1699 sc->proto_dlcr5 | FE_D5_AFM0 | FE_D5_AFM1);
1700 sc->filter_change = 0;
1701
1702 #if FE_DEBUG >= 3
1703 log(LOG_INFO, "%s: promiscuous mode\n", sc->sc_dev.dv_xname);
1704 #endif
1705 return;
1706 }
1707
1708 /*
1709 * Turn the chip to the normal (non-promiscuous) mode.
1710 */
1711 bus_space_write_1(bst, bsh, FE_DLCR5, sc->proto_dlcr5 | FE_D5_AFM1);
1712
1713 /*
1714 * Find the new multicast filter value.
1715 */
1716 mb86960_getmcaf(&sc->sc_ec, sc->filter);
1717 sc->filter_change = 1;
1718
1719 #if FE_DEBUG >= 3
1720 log(LOG_INFO,
1721 "%s: address filter: [%02x %02x %02x %02x %02x %02x %02x %02x]\n",
1722 sc->sc_dev.dv_xname,
1723 sc->filter[0], sc->filter[1], sc->filter[2], sc->filter[3],
1724 sc->filter[4], sc->filter[5], sc->filter[6], sc->filter[7]);
1725 #endif
1726
1727 /*
1728 * We have to update the multicast filter in the 86960, A.S.A.P.
1729 *
1730 * Note that the DLC (Data Linc Control unit, i.e. transmitter
1731 * and receiver) must be stopped when feeding the filter, and
1732 * DLC trashes all packets in both transmission and receive
1733 * buffers when stopped.
1734 *
1735 * ... Are the above sentenses correct? I have to check the
1736 * manual of the MB86960A. FIXME.
1737 *
1738 * To reduce the packet lossage, we delay the filter update
1739 * process until buffers are empty.
1740 */
1741 if (sc->txb_sched == 0 && sc->txb_count == 0 &&
1742 (bus_space_read_1(bst, bsh, FE_DLCR1) & FE_D1_PKTRDY) == 0) {
1743 /*
1744 * Buffers are (apparently) empty. Load
1745 * the new filter value into MARs now.
1746 */
1747 mb86960_loadmar(sc);
1748 } else {
1749 /*
1750 * Buffers are not empty. Mark that we have to update
1751 * the MARs. The new filter will be loaded by mb86960_intr()
1752 * later.
1753 */
1754 #if FE_DEBUG >= 4
1755 log(LOG_INFO, "%s: filter change delayed\n",
1756 sc->sc_dev.dv_xname);
1757 #endif
1758 }
1759 }
1760
1761 /*
1762 * Load a new multicast address filter into MARs.
1763 *
1764 * The caller must have splnet'ed befor mb86960_loadmar.
1765 * This function starts the DLC upon return. So it can be called only
1766 * when the chip is working, i.e., from the driver's point of view, when
1767 * a device is RUNNING. (I mistook the point in previous versions.)
1768 */
1769 void
1770 mb86960_loadmar(sc)
1771 struct mb86960_softc *sc;
1772 {
1773 bus_space_tag_t bst = sc->sc_bst;
1774 bus_space_handle_t bsh = sc->sc_bsh;
1775
1776 /* Stop the DLC (transmitter and receiver). */
1777 bus_space_write_1(bst, bsh, FE_DLCR6,
1778 sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
1779
1780 /* Select register bank 1 for MARs. */
1781 bus_space_write_1(bst, bsh, FE_DLCR7,
1782 sc->proto_dlcr7 | FE_D7_RBS_MAR | FE_D7_POWER_UP);
1783
1784 /* Copy filter value into the registers. */
1785 bus_space_write_region_1(bst, bsh, FE_MAR8, sc->filter, FE_FILTER_LEN);
1786
1787 /* Restore the bank selection for BMPRs (i.e., runtime registers). */
1788 bus_space_write_1(bst, bsh, FE_DLCR7,
1789 sc->proto_dlcr7 | FE_D7_RBS_BMPR | FE_D7_POWER_UP);
1790
1791 /* Restart the DLC. */
1792 bus_space_write_1(bst, bsh, FE_DLCR6,
1793 sc->proto_dlcr6 | FE_D6_DLC_ENABLE);
1794
1795 /* We have just updated the filter. */
1796 sc->filter_change = 0;
1797
1798 #if FE_DEBUG >= 3
1799 log(LOG_INFO, "%s: address filter changed\n", sc->sc_dev.dv_xname);
1800 #endif
1801 }
1802
1803 /*
1804 * Enable power on the interface.
1805 */
1806 int
1807 mb86960_enable(sc)
1808 struct mb86960_softc *sc;
1809 {
1810
1811 #if FE_DEBUG >= 3
1812 log(LOG_INFO, "%s: mb86960_enable()\n", sc->sc_dev.dv_xname);
1813 #endif
1814
1815 if ((sc->sc_stat & FE_STAT_ENABLED) == 0 && sc->sc_enable != NULL) {
1816 if ((*sc->sc_enable)(sc) != 0) {
1817 printf("%s: device enable failed\n",
1818 sc->sc_dev.dv_xname);
1819 return (EIO);
1820 }
1821 }
1822
1823 sc->sc_stat |= FE_STAT_ENABLED;
1824 return (0);
1825 }
1826
1827 /*
1828 * Disable power on the interface.
1829 */
1830 void
1831 mb86960_disable(sc)
1832 struct mb86960_softc *sc;
1833 {
1834
1835 #if FE_DEBUG >= 3
1836 log(LOG_INFO, "%s: mb86960_disable()\n", sc->sc_dev.dv_xname);
1837 #endif
1838
1839 if ((sc->sc_stat & FE_STAT_ENABLED) != 0 && sc->sc_disable != NULL) {
1840 (*sc->sc_disable)(sc);
1841 sc->sc_stat &= ~FE_STAT_ENABLED;
1842 }
1843 }
1844
1845 /*
1846 * mbe_activate:
1847 *
1848 * Handle device activation/deactivation requests.
1849 */
1850 int
1851 mb86960_activate(self, act)
1852 struct device *self;
1853 enum devact act;
1854 {
1855 struct mb86960_softc *sc = (struct mb86960_softc *)self;
1856 int rv, s;
1857
1858 rv = 0;
1859 s = splnet();
1860 switch (act) {
1861 case DVACT_ACTIVATE:
1862 rv = EOPNOTSUPP;
1863 break;
1864
1865 case DVACT_DEACTIVATE:
1866 if_deactivate(&sc->sc_ec.ec_if);
1867 break;
1868 }
1869 splx(s);
1870 return (rv);
1871 }
1872
1873 /*
1874 * mb86960_detach:
1875 *
1876 * Detach a MB86960 interface.
1877 */
1878 int
1879 mb86960_detach(sc)
1880 struct mb86960_softc *sc;
1881 {
1882 struct ifnet *ifp = &sc->sc_ec.ec_if;
1883
1884 /* Succeed now if there's no work to do. */
1885 if ((sc->sc_stat & FE_STAT_ATTACHED) == 0)
1886 return (0);
1887
1888 /* Delete all media. */
1889 ifmedia_delete_instance(&sc->sc_media, IFM_INST_ANY);
1890
1891 #if NRND > 0
1892 /* Unhook the entropy source. */
1893 rnd_detach_source(&sc->rnd_source);
1894 #endif
1895 ether_ifdetach(ifp);
1896 if_detach(ifp);
1897
1898 mb86960_disable(sc);
1899 return (0);
1900 }
1901
1902 /*
1903 * Routines to read all bytes from the config EEPROM (93C06) through MB86965A.
1904 */
1905 void
1906 mb86965_read_eeprom(iot, ioh, data)
1907 bus_space_tag_t iot;
1908 bus_space_handle_t ioh;
1909 u_int8_t *data;
1910 {
1911 int addr, op, bit;
1912 u_int16_t val;
1913
1914 /* Read bytes from EEPROM; two bytes per an iteration. */
1915 for (addr = 0; addr < FE_EEPROM_SIZE / 2; addr++) {
1916 /* Reset the EEPROM interface. */
1917 bus_space_write_1(iot, ioh, FE_BMPR16, 0x00);
1918 bus_space_write_1(iot, ioh, FE_BMPR17, 0x00);
1919 bus_space_write_1(iot, ioh, FE_BMPR16, FE_B16_SELECT);
1920
1921 /* Send start bit. */
1922 bus_space_write_1(iot, ioh, FE_BMPR17, FE_B17_DATA);
1923 FE_EEPROM_DELAY();
1924 bus_space_write_1(iot, ioh,
1925 FE_BMPR16, FE_B16_SELECT | FE_B16_CLOCK);
1926 FE_EEPROM_DELAY();
1927 bus_space_write_1(iot, ioh, FE_BMPR16, FE_B16_SELECT);
1928
1929 /* Send read command and read address. */
1930 op = 0x80 | addr; /* READ instruction */
1931 for (bit = 8; bit > 0; bit--) {
1932 bus_space_write_1(iot, ioh, FE_BMPR17,
1933 (op & (1 << (bit - 1))) ? FE_B17_DATA : 0);
1934 FE_EEPROM_DELAY();
1935 bus_space_write_1(iot, ioh,
1936 FE_BMPR16, FE_B16_SELECT | FE_B16_CLOCK);
1937 FE_EEPROM_DELAY();
1938 bus_space_write_1(iot, ioh, FE_BMPR16, FE_B16_SELECT);
1939 }
1940 bus_space_write_1(iot, ioh, FE_BMPR17, 0x00);
1941
1942 /* Read two bytes in each address */
1943 val = 0;
1944 for (bit = 16; bit > 0; bit--) {
1945 FE_EEPROM_DELAY();
1946 bus_space_write_1(iot, ioh,
1947 FE_BMPR16, FE_B16_SELECT | FE_B16_CLOCK);
1948 FE_EEPROM_DELAY();
1949 if (bus_space_read_1(iot, ioh, FE_BMPR17) &
1950 FE_B17_DATA)
1951 val |= 1 << (bit - 1);
1952 bus_space_write_1(iot, ioh,
1953 FE_BMPR16, FE_B16_SELECT);
1954 }
1955 data[addr * 2] = val >> 8;
1956 data[addr * 2 + 1] = val & 0xff;
1957 }
1958
1959 /* Make sure the EEPROM is turned off. */
1960 bus_space_write_1(iot, ioh, FE_BMPR16, 0);
1961 bus_space_write_1(iot, ioh, FE_BMPR17, 0);
1962
1963 #if FE_DEBUG >= 3
1964 /* Report what we got. */
1965 log(LOG_INFO, "mb86965_read_eeprom: "
1966 " %02x%02x%02x%02x %02x%02x%02x%02x -"
1967 " %02x%02x%02x%02x %02x%02x%02x%02x -"
1968 " %02x%02x%02x%02x %02x%02x%02x%02x -"
1969 " %02x%02x%02x%02x %02x%02x%02x%02x\n",
1970 data[ 0], data[ 1], data[ 2], data[ 3],
1971 data[ 4], data[ 5], data[ 6], data[ 7],
1972 data[ 8], data[ 9], data[10], data[11],
1973 data[12], data[13], data[14], data[15],
1974 data[16], data[17], data[18], data[19],
1975 data[20], data[21], data[22], data[23],
1976 data[24], data[25], data[26], data[27],
1977 data[28], data[29], data[30], data[31]);
1978 #endif
1979 }
1980
1981 #if FE_DEBUG >= 1
1982 void
1983 mb86960_dump(level, sc)
1984 int level;
1985 struct mb86960_softc *sc;
1986 {
1987 bus_space_tag_t bst = sc->sc_bst;
1988 bus_space_handle_t bsh = sc->sc_bsh;
1989 u_int8_t save_dlcr7;
1990
1991 save_dlcr7 = bus_space_read_1(bst, bsh, FE_DLCR7);
1992
1993 log(level, "\tDLCR = %02x %02x %02x %02x %02x %02x %02x %02x\n",
1994 bus_space_read_1(bst, bsh, FE_DLCR0),
1995 bus_space_read_1(bst, bsh, FE_DLCR1),
1996 bus_space_read_1(bst, bsh, FE_DLCR2),
1997 bus_space_read_1(bst, bsh, FE_DLCR3),
1998 bus_space_read_1(bst, bsh, FE_DLCR4),
1999 bus_space_read_1(bst, bsh, FE_DLCR5),
2000 bus_space_read_1(bst, bsh, FE_DLCR6),
2001 bus_space_read_1(bst, bsh, FE_DLCR7));
2002
2003 bus_space_write_1(bst, bsh, FE_DLCR7,
2004 (save_dlcr7 & ~FE_D7_RBS) | FE_D7_RBS_DLCR);
2005 log(level, "\t %02x %02x %02x %02x %02x %02x %02x %02x\n",
2006 bus_space_read_1(bst, bsh, FE_DLCR8),
2007 bus_space_read_1(bst, bsh, FE_DLCR9),
2008 bus_space_read_1(bst, bsh, FE_DLCR10),
2009 bus_space_read_1(bst, bsh, FE_DLCR11),
2010 bus_space_read_1(bst, bsh, FE_DLCR12),
2011 bus_space_read_1(bst, bsh, FE_DLCR13),
2012 bus_space_read_1(bst, bsh, FE_DLCR14),
2013 bus_space_read_1(bst, bsh, FE_DLCR15));
2014
2015 bus_space_write_1(bst, bsh, FE_DLCR7,
2016 (save_dlcr7 & ~FE_D7_RBS) | FE_D7_RBS_MAR);
2017 log(level, "\tMAR = %02x %02x %02x %02x %02x %02x %02x %02x\n",
2018 bus_space_read_1(bst, bsh, FE_MAR8),
2019 bus_space_read_1(bst, bsh, FE_MAR9),
2020 bus_space_read_1(bst, bsh, FE_MAR10),
2021 bus_space_read_1(bst, bsh, FE_MAR11),
2022 bus_space_read_1(bst, bsh, FE_MAR12),
2023 bus_space_read_1(bst, bsh, FE_MAR13),
2024 bus_space_read_1(bst, bsh, FE_MAR14),
2025 bus_space_read_1(bst, bsh, FE_MAR15));
2026
2027 bus_space_write_1(bst, bsh, FE_DLCR7,
2028 (save_dlcr7 & ~FE_D7_RBS) | FE_D7_RBS_BMPR);
2029 log(level,
2030 "\tBMPR = xx xx %02x %02x %02x %02x %02x %02x %02x %02x xx %02x\n",
2031 bus_space_read_1(bst, bsh, FE_BMPR10),
2032 bus_space_read_1(bst, bsh, FE_BMPR11),
2033 bus_space_read_1(bst, bsh, FE_BMPR12),
2034 bus_space_read_1(bst, bsh, FE_BMPR13),
2035 bus_space_read_1(bst, bsh, FE_BMPR14),
2036 bus_space_read_1(bst, bsh, FE_BMPR15),
2037 bus_space_read_1(bst, bsh, FE_BMPR16),
2038 bus_space_read_1(bst, bsh, FE_BMPR17),
2039 bus_space_read_1(bst, bsh, FE_BMPR19));
2040
2041 bus_space_write_1(bst, bsh, FE_DLCR7, save_dlcr7);
2042 }
2043 #endif
2044
Cache object: 86fe0758d5d51fdf5902a5fe0df11a27
|