2 * Copyright (c) 2008 Benno Rice. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 #include <sys/cdefs.h>
26 __FBSDID("$FreeBSD$");
29 * Driver for SMSC LAN91C111, may work for older variants.
32 #ifdef HAVE_KERNEL_OPTION_HEADERS
33 #include "opt_device_polling.h"
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/errno.h>
39 #include <sys/kernel.h>
40 #include <sys/sockio.h>
41 #include <sys/malloc.h>
43 #include <sys/queue.h>
44 #include <sys/socket.h>
45 #include <sys/syslog.h>
46 #include <sys/taskqueue.h>
48 #include <sys/module.h>
51 #include <machine/bus.h>
52 #include <machine/resource.h>
55 #include <net/ethernet.h>
57 #include <net/if_arp.h>
58 #include <net/if_dl.h>
59 #include <net/if_types.h>
60 #include <net/if_mib.h>
61 #include <net/if_media.h>
64 #include <netinet/in.h>
65 #include <netinet/in_systm.h>
66 #include <netinet/in_var.h>
67 #include <netinet/ip.h>
71 #include <net/bpfdesc.h>
73 #include <dev/smc/if_smcreg.h>
74 #include <dev/smc/if_smcvar.h>
76 #include <dev/mii/mii.h>
77 #include <dev/mii/miivar.h>
79 #define SMC_LOCK(sc) mtx_lock(&(sc)->smc_mtx)
80 #define SMC_UNLOCK(sc) mtx_unlock(&(sc)->smc_mtx)
81 #define SMC_ASSERT_LOCKED(sc) mtx_assert(&(sc)->smc_mtx, MA_OWNED)
83 #define SMC_INTR_PRIORITY 0
84 #define SMC_RX_PRIORITY 5
85 #define SMC_TX_PRIORITY 10
87 devclass_t smc_devclass;
89 static const char *smc_chip_ids[16] = {
91 /* 3 */ "SMSC LAN91C90 or LAN91C92",
92 /* 4 */ "SMSC LAN91C94",
93 /* 5 */ "SMSC LAN91C95",
94 /* 6 */ "SMSC LAN91C96",
95 /* 7 */ "SMSC LAN91C100",
96 /* 8 */ "SMSC LAN91C100FD",
97 /* 9 */ "SMSC LAN91C110FD or LAN91C111FD",
102 static void smc_init(void *);
103 static void smc_start(struct ifnet *);
104 static void smc_stop(struct smc_softc *);
105 static int smc_ioctl(struct ifnet *, u_long, caddr_t);
107 static void smc_init_locked(struct smc_softc *);
108 static void smc_start_locked(struct ifnet *);
109 static void smc_reset(struct smc_softc *);
110 static int smc_mii_ifmedia_upd(struct ifnet *);
111 static void smc_mii_ifmedia_sts(struct ifnet *, struct ifmediareq *);
112 static void smc_mii_tick(void *);
113 static void smc_mii_mediachg(struct smc_softc *);
114 static int smc_mii_mediaioctl(struct smc_softc *, struct ifreq *, u_long);
116 static void smc_task_intr(void *, int);
117 static void smc_task_rx(void *, int);
118 static void smc_task_tx(void *, int);
120 static driver_filter_t smc_intr;
121 static timeout_t smc_watchdog;
122 #ifdef DEVICE_POLLING
123 static poll_handler_t smc_poll;
127 smc_select_bank(struct smc_softc *sc, uint16_t bank)
130 bus_write_2(sc->smc_reg, BSR, bank & BSR_BANK_MASK);
133 /* Never call this when not in bank 2. */
135 smc_mmu_wait(struct smc_softc *sc)
138 KASSERT((bus_read_2(sc->smc_reg, BSR) &
139 BSR_BANK_MASK) == 2, ("%s: smc_mmu_wait called when not in bank 2",
140 device_get_nameunit(sc->smc_dev)));
141 while (bus_read_2(sc->smc_reg, MMUCR) & MMUCR_BUSY)
145 static __inline uint8_t
146 smc_read_1(struct smc_softc *sc, bus_addr_t offset)
149 return (bus_read_1(sc->smc_reg, offset));
153 smc_write_1(struct smc_softc *sc, bus_addr_t offset, uint8_t val)
156 bus_write_1(sc->smc_reg, offset, val);
159 static __inline uint16_t
160 smc_read_2(struct smc_softc *sc, bus_addr_t offset)
163 return (bus_read_2(sc->smc_reg, offset));
167 smc_write_2(struct smc_softc *sc, bus_addr_t offset, uint16_t val)
170 bus_write_2(sc->smc_reg, offset, val);
174 smc_read_multi_2(struct smc_softc *sc, bus_addr_t offset, uint16_t *datap,
178 bus_read_multi_2(sc->smc_reg, offset, datap, count);
182 smc_write_multi_2(struct smc_softc *sc, bus_addr_t offset, uint16_t *datap,
186 bus_write_multi_2(sc->smc_reg, offset, datap, count);
190 smc_probe(device_t dev)
192 int rid, type, error;
194 struct smc_softc *sc;
195 struct resource *reg;
197 sc = device_get_softc(dev);
199 type = SYS_RES_IOPORT;
203 type = SYS_RES_MEMORY;
205 reg = bus_alloc_resource(dev, type, &rid, 0, ~0, 16, RF_ACTIVE);
209 "could not allocate I/O resource for probe\n");
213 /* Check for the identification value in the BSR. */
214 val = bus_read_2(reg, BSR);
215 if ((val & BSR_IDENTIFY_MASK) != BSR_IDENTIFY) {
217 device_printf(dev, "identification value not in BSR\n");
223 * Try switching banks and make sure we still get the identification
226 bus_write_2(reg, BSR, 0);
227 val = bus_read_2(reg, BSR);
228 if ((val & BSR_IDENTIFY_MASK) != BSR_IDENTIFY) {
231 "identification value not in BSR after write\n");
238 bus_write_2(reg, BSR, 1);
239 val = bus_read_2(reg, BAR);
240 val = BAR_ADDRESS(val);
241 if (rman_get_start(reg) != val) {
243 device_printf(dev, "BAR address %x does not match "
244 "I/O resource address %lx\n", val,
245 rman_get_start(reg));
251 /* Compare REV against known chip revisions. */
252 bus_write_2(reg, BSR, 3);
253 val = bus_read_2(reg, REV);
254 val = (val & REV_CHIP_MASK) >> REV_CHIP_SHIFT;
255 if (smc_chip_ids[val] == NULL) {
257 device_printf(dev, "Unknown chip revision: %d\n", val);
262 device_set_desc(dev, smc_chip_ids[val]);
265 bus_release_resource(dev, type, rid, reg);
270 smc_attach(device_t dev)
274 u_char eaddr[ETHER_ADDR_LEN];
275 struct smc_softc *sc;
278 sc = device_get_softc(dev);
283 ifp = sc->smc_ifp = if_alloc(IFT_ETHER);
289 mtx_init(&sc->smc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
291 /* Set up watchdog callout. */
292 callout_init_mtx(&sc->smc_watchdog, &sc->smc_mtx, 0);
294 type = SYS_RES_IOPORT;
296 type = SYS_RES_MEMORY;
299 sc->smc_reg = bus_alloc_resource(dev, type, &sc->smc_reg_rid, 0, ~0,
301 if (sc->smc_reg == NULL) {
306 sc->smc_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &sc->smc_irq_rid, 0,
307 ~0, 1, RF_ACTIVE | RF_SHAREABLE);
308 if (sc->smc_irq == NULL) {
317 smc_select_bank(sc, 3);
318 val = smc_read_2(sc, REV);
319 sc->smc_chip = (val & REV_CHIP_MASK) >> REV_CHIP_SHIFT;
320 sc->smc_rev = (val * REV_REV_MASK) >> REV_REV_SHIFT;
322 device_printf(dev, "revision %x\n", sc->smc_rev);
324 callout_init_mtx(&sc->smc_mii_tick_ch, &sc->smc_mtx,
325 CALLOUT_RETURNUNLOCKED);
326 if (sc->smc_chip >= REV_CHIP_91110FD) {
327 mii_phy_probe(dev, &sc->smc_miibus, smc_mii_ifmedia_upd,
328 smc_mii_ifmedia_sts);
329 if (sc->smc_miibus != NULL) {
330 sc->smc_mii_tick = smc_mii_tick;
331 sc->smc_mii_mediachg = smc_mii_mediachg;
332 sc->smc_mii_mediaioctl = smc_mii_mediaioctl;
336 smc_select_bank(sc, 1);
337 eaddr[0] = smc_read_1(sc, IAR0);
338 eaddr[1] = smc_read_1(sc, IAR1);
339 eaddr[2] = smc_read_1(sc, IAR2);
340 eaddr[3] = smc_read_1(sc, IAR3);
341 eaddr[4] = smc_read_1(sc, IAR4);
342 eaddr[5] = smc_read_1(sc, IAR5);
344 if_initname(ifp, device_get_name(dev), device_get_unit(dev));
346 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
347 ifp->if_init = smc_init;
348 ifp->if_ioctl = smc_ioctl;
349 ifp->if_start = smc_start;
350 IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
351 IFQ_SET_READY(&ifp->if_snd);
353 ifp->if_capabilities = ifp->if_capenable = 0;
355 #ifdef DEVICE_POLLING
356 ifp->if_capabilities |= IFCAP_POLLING;
359 ether_ifattach(ifp, eaddr);
361 /* Set up taskqueue */
362 TASK_INIT(&sc->smc_intr, SMC_INTR_PRIORITY, smc_task_intr, ifp);
363 TASK_INIT(&sc->smc_rx, SMC_RX_PRIORITY, smc_task_rx, ifp);
364 TASK_INIT(&sc->smc_tx, SMC_TX_PRIORITY, smc_task_tx, ifp);
365 sc->smc_tq = taskqueue_create_fast("smc_taskq", M_NOWAIT,
366 taskqueue_thread_enqueue, &sc->smc_tq);
367 taskqueue_start_threads(&sc->smc_tq, 1, PI_NET, "%s taskq",
368 device_get_nameunit(sc->smc_dev));
370 /* Mask all interrupts. */
372 smc_write_1(sc, MSK, 0);
374 /* Wire up interrupt */
375 error = bus_setup_intr(dev, sc->smc_irq,
376 INTR_TYPE_NET|INTR_MPSAFE, smc_intr, NULL, sc, &sc->smc_ih);
387 smc_detach(device_t dev)
390 struct smc_softc *sc;
392 sc = device_get_softc(dev);
397 if (sc->smc_ifp != NULL) {
398 ether_ifdetach(sc->smc_ifp);
401 callout_drain(&sc->smc_watchdog);
402 callout_drain(&sc->smc_mii_tick_ch);
404 #ifdef DEVICE_POLLING
405 if (sc->smc_ifp->if_capenable & IFCAP_POLLING)
406 ether_poll_deregister(sc->smc_ifp);
409 if (sc->smc_ih != NULL)
410 bus_teardown_intr(sc->smc_dev, sc->smc_irq, sc->smc_ih);
412 if (sc->smc_tq != NULL) {
413 taskqueue_drain(sc->smc_tq, &sc->smc_intr);
414 taskqueue_drain(sc->smc_tq, &sc->smc_rx);
415 taskqueue_drain(sc->smc_tq, &sc->smc_tx);
416 taskqueue_free(sc->smc_tq);
420 if (sc->smc_ifp != NULL) {
421 if_free(sc->smc_ifp);
424 if (sc->smc_miibus != NULL) {
425 device_delete_child(sc->smc_dev, sc->smc_miibus);
426 bus_generic_detach(sc->smc_dev);
429 if (sc->smc_reg != NULL) {
430 type = SYS_RES_IOPORT;
432 type = SYS_RES_MEMORY;
434 bus_release_resource(sc->smc_dev, type, sc->smc_reg_rid,
438 if (sc->smc_irq != NULL)
439 bus_release_resource(sc->smc_dev, SYS_RES_IRQ, sc->smc_irq_rid,
442 if (mtx_initialized(&sc->smc_mtx))
443 mtx_destroy(&sc->smc_mtx);
449 smc_start(struct ifnet *ifp)
451 struct smc_softc *sc;
455 smc_start_locked(ifp);
460 smc_start_locked(struct ifnet *ifp)
462 struct smc_softc *sc;
464 u_int len, npages, spin_count;
467 SMC_ASSERT_LOCKED(sc);
469 if (ifp->if_drv_flags & IFF_DRV_OACTIVE)
471 if (IFQ_IS_EMPTY(&ifp->if_snd))
475 * Grab the next packet. If it's too big, drop it.
477 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
478 len = m_length(m, NULL);
480 if (len > ETHER_MAX_LEN - ETHER_CRC_LEN) {
481 if_printf(ifp, "large packet discarded\n");
484 return; /* XXX readcheck? */
488 * Flag that we're busy.
490 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
494 * Work out how many 256 byte "pages" we need. We have to include the
495 * control data for the packet in this calculation.
497 npages = (len * PKT_CTRL_DATA_LEN) >> 8;
504 smc_select_bank(sc, 2);
506 smc_write_2(sc, MMUCR, MMUCR_CMD_TX_ALLOC | npages);
509 * Spin briefly to see if the allocation succeeds.
511 spin_count = TX_ALLOC_WAIT_TIME;
513 if (smc_read_1(sc, IST) & ALLOC_INT) {
514 smc_write_1(sc, ACK, ALLOC_INT);
517 } while (--spin_count);
520 * If the allocation is taking too long, unmask the alloc interrupt
523 if (spin_count == 0) {
524 sc->smc_mask |= ALLOC_INT;
525 if ((ifp->if_capenable & IFCAP_POLLING) == 0)
526 smc_write_1(sc, MSK, sc->smc_mask);
530 taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_tx);
534 smc_task_tx(void *context, int pending)
537 struct smc_softc *sc;
543 ifp = (struct ifnet *)context;
548 if (sc->smc_pending == NULL) {
553 m = m0 = sc->smc_pending;
554 sc->smc_pending = NULL;
555 smc_select_bank(sc, 2);
558 * Check the allocation result.
560 packet = smc_read_1(sc, ARR);
563 * If the allocation failed, requeue the packet and retry.
565 if (packet & ARR_FAILED) {
566 IFQ_DRV_PREPEND(&ifp->if_snd, m);
568 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
569 smc_start_locked(ifp);
575 * Tell the device to write to our packet number.
577 smc_write_1(sc, PNR, packet);
578 smc_write_2(sc, PTR, 0 | PTR_AUTO_INCR);
581 * Tell the device how long the packet is (including control data).
583 len = m_length(m, 0);
584 len += PKT_CTRL_DATA_LEN;
585 smc_write_2(sc, DATA0, 0);
586 smc_write_2(sc, DATA0, len);
589 * Push the data out to the device.
592 for (; m != NULL; m = m->m_next) {
593 data = mtod(m, uint8_t *);
594 smc_write_multi_2(sc, DATA0, (uint16_t *)data, m->m_len / 2);
598 * Push out the control byte and and the odd byte if needed.
600 if ((len & 1) != 0 && data != NULL)
601 smc_write_2(sc, DATA0, (CTRL_ODD << 8) | data[m->m_len - 1]);
603 smc_write_2(sc, DATA0, 0);
606 * Unmask the TX empty interrupt.
608 sc->smc_mask |= TX_EMPTY_INT;
609 if ((ifp->if_capenable & IFCAP_POLLING) == 0)
610 smc_write_1(sc, MSK, sc->smc_mask);
613 * Enqueue the packet.
616 smc_write_2(sc, MMUCR, MMUCR_CMD_ENQUEUE);
617 callout_reset(&sc->smc_watchdog, hz * 2, smc_watchdog, sc);
623 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
630 * See if there's anything else to do.
636 smc_task_rx(void *context, int pending)
638 u_int packet, status, len;
641 struct smc_softc *sc;
642 struct mbuf *m, *mhead, *mtail;
645 ifp = (struct ifnet *)context;
647 mhead = mtail = NULL;
651 packet = smc_read_1(sc, FIFO_RX);
652 while ((packet & FIFO_EMPTY) == 0) {
654 * Grab an mbuf and attach a cluster.
656 MGETHDR(m, M_DONTWAIT, MT_DATA);
660 MCLGET(m, M_DONTWAIT);
661 if ((m->m_flags & M_EXT) == 0) {
667 * Point to the start of the packet.
669 smc_select_bank(sc, 2);
670 smc_write_1(sc, PNR, packet);
671 smc_write_2(sc, PTR, 0 | PTR_READ | PTR_RCV | PTR_AUTO_INCR);
674 * Grab status and packet length.
676 status = smc_read_2(sc, DATA0);
677 len = smc_read_2(sc, DATA0) & RX_LEN_MASK;
679 if (status & RX_ODDFRM)
685 if (status & (RX_TOOSHORT | RX_TOOLNG | RX_BADCRC | RX_ALGNERR)) {
687 smc_write_2(sc, MMUCR, MMUCR_CMD_RELEASE);
694 * Set the mbuf up the way we want it.
696 m->m_pkthdr.rcvif = ifp;
697 m->m_pkthdr.len = m->m_len = len + 2; /* XXX: Is this right? */
698 m_adj(m, ETHER_ALIGN);
701 * Pull the packet out of the device. Make sure we're in the
702 * right bank first as things may have changed while we were
703 * allocating our mbuf.
705 smc_select_bank(sc, 2);
706 smc_write_1(sc, PNR, packet);
707 smc_write_2(sc, PTR, 4 | PTR_READ | PTR_RCV | PTR_AUTO_INCR);
708 data = mtod(m, uint8_t *);
709 smc_read_multi_2(sc, DATA0, (uint16_t *)data, len >> 1);
712 *data = smc_read_1(sc, DATA0);
716 * Tell the device we're done.
719 smc_write_2(sc, MMUCR, MMUCR_CMD_RELEASE);
731 packet = smc_read_1(sc, FIFO_RX);
734 sc->smc_mask |= RCV_INT;
735 if ((ifp->if_capenable & IFCAP_POLLING) == 0)
736 smc_write_1(sc, MSK, sc->smc_mask);
740 while (mhead != NULL) {
742 mhead = mhead->m_next;
745 (*ifp->if_input)(ifp, m);
749 #ifdef DEVICE_POLLING
751 smc_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
753 struct smc_softc *sc;
758 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
764 if (cmd == POLL_AND_CHECK_STATUS)
765 taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_intr);
770 smc_intr(void *context)
772 struct smc_softc *sc;
774 sc = (struct smc_softc *)context;
775 taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_intr);
776 return (FILTER_HANDLED);
780 smc_task_intr(void *context, int pending)
782 struct smc_softc *sc;
784 u_int status, packet, counter, tcr;
787 ifp = (struct ifnet *)context;
792 smc_select_bank(sc, 2);
795 * Get the current mask, and then block all interrupts while we're
798 if ((ifp->if_capenable & IFCAP_POLLING) == 0)
799 smc_write_1(sc, MSK, 0);
802 * Find out what interrupts are flagged.
804 status = smc_read_1(sc, IST) & sc->smc_mask;
809 if (status & TX_INT) {
811 * Kill off the packet if there is one and re-enable transmit.
813 packet = smc_read_1(sc, FIFO_TX);
814 if ((packet & FIFO_EMPTY) == 0) {
815 smc_write_1(sc, PNR, packet);
816 smc_write_2(sc, PTR, 0 | PTR_READ |
818 tcr = smc_read_2(sc, DATA0);
819 if ((tcr & EPHSR_TX_SUC) == 0)
820 device_printf(sc->smc_dev,
823 smc_write_2(sc, MMUCR, MMUCR_CMD_RELEASE_PKT);
825 smc_select_bank(sc, 0);
826 tcr = smc_read_2(sc, TCR);
827 tcr |= TCR_TXENA | TCR_PAD_EN;
828 smc_write_2(sc, TCR, tcr);
829 smc_select_bank(sc, 2);
830 taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_tx);
836 smc_write_1(sc, ACK, TX_INT);
842 if (status & RCV_INT) {
843 smc_write_1(sc, ACK, RCV_INT);
844 sc->smc_mask &= ~RCV_INT;
845 taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_rx);
851 if (status & ALLOC_INT) {
852 smc_write_1(sc, ACK, ALLOC_INT);
853 sc->smc_mask &= ~ALLOC_INT;
854 taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_tx);
860 if (status & RX_OVRN_INT) {
861 smc_write_1(sc, ACK, RX_OVRN_INT);
868 if (status & TX_EMPTY_INT) {
869 smc_write_1(sc, ACK, TX_EMPTY_INT);
870 sc->smc_mask &= ~TX_EMPTY_INT;
871 callout_stop(&sc->smc_watchdog);
874 * Update collision stats.
876 smc_select_bank(sc, 0);
877 counter = smc_read_2(sc, ECR);
878 smc_select_bank(sc, 2);
879 ifp->if_collisions +=
880 (counter & ECR_SNGLCOL_MASK) >> ECR_SNGLCOL_SHIFT;
881 ifp->if_collisions +=
882 (counter & ECR_MULCOL_MASK) >> ECR_MULCOL_SHIFT;
885 * See if there are any packets to transmit.
887 taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_tx);
891 * Update the interrupt mask.
893 if ((ifp->if_capenable & IFCAP_POLLING) == 0)
894 smc_write_1(sc, MSK, sc->smc_mask);
900 smc_mii_readbits(struct smc_softc *sc, int nbits)
902 u_int mgmt, mask, val;
904 SMC_ASSERT_LOCKED(sc);
905 KASSERT((smc_read_2(sc, BSR) & BSR_BANK_MASK) == 3,
906 ("%s: smc_mii_readbits called with bank %d (!= 3)",
907 device_get_nameunit(sc->smc_dev),
908 smc_read_2(sc, BSR) & BSR_BANK_MASK));
911 * Set up the MGMT (aka MII) register.
913 mgmt = smc_read_2(sc, MGMT) & ~(MGMT_MCLK | MGMT_MDOE | MGMT_MDO);
914 smc_write_2(sc, MGMT, mgmt);
919 for (mask = 1 << (nbits - 1), val = 0; mask; mask >>= 1) {
920 if (smc_read_2(sc, MGMT) & MGMT_MDI)
923 smc_write_2(sc, MGMT, mgmt);
925 smc_write_2(sc, MGMT, mgmt | MGMT_MCLK);
933 smc_mii_writebits(struct smc_softc *sc, u_int val, int nbits)
937 SMC_ASSERT_LOCKED(sc);
938 KASSERT((smc_read_2(sc, BSR) & BSR_BANK_MASK) == 3,
939 ("%s: smc_mii_writebits called with bank %d (!= 3)",
940 device_get_nameunit(sc->smc_dev),
941 smc_read_2(sc, BSR) & BSR_BANK_MASK));
944 * Set up the MGMT (aka MII) register).
946 mgmt = smc_read_2(sc, MGMT) & ~(MGMT_MCLK | MGMT_MDOE | MGMT_MDO);
952 for (mask = 1 << (nbits - 1); mask; mask >>= 1) {
958 smc_write_2(sc, MGMT, mgmt);
960 smc_write_2(sc, MGMT, mgmt | MGMT_MCLK);
966 smc_miibus_readreg(device_t dev, int phy, int reg)
968 struct smc_softc *sc;
971 sc = device_get_softc(dev);
975 smc_select_bank(sc, 3);
978 * Send out the idle pattern.
980 smc_mii_writebits(sc, 0xffffffff, 32);
983 * Start code + read opcode + phy address + phy register
985 smc_mii_writebits(sc, 6 << 10 | phy << 5 | reg, 14);
990 val = smc_mii_readbits(sc, 18);
993 * Reset the MDIO interface.
995 smc_write_2(sc, MGMT,
996 smc_read_2(sc, MGMT) & ~(MGMT_MCLK | MGMT_MDOE | MGMT_MDO));
1003 smc_miibus_writereg(device_t dev, int phy, int reg, int data)
1005 struct smc_softc *sc;
1007 sc = device_get_softc(dev);
1011 smc_select_bank(sc, 3);
1014 * Send idle pattern.
1016 smc_mii_writebits(sc, 0xffffffff, 32);
1019 * Start code + write opcode + phy address + phy register + turnaround
1022 smc_mii_writebits(sc, 5 << 28 | phy << 23 | reg << 18 | 2 << 16 | data,
1026 * Reset MDIO interface.
1028 smc_write_2(sc, MGMT,
1029 smc_read_2(sc, MGMT) & ~(MGMT_MCLK | MGMT_MDOE | MGMT_MDO));
1036 smc_miibus_statchg(device_t dev)
1038 struct smc_softc *sc;
1039 struct mii_data *mii;
1042 sc = device_get_softc(dev);
1043 mii = device_get_softc(sc->smc_miibus);
1047 smc_select_bank(sc, 0);
1048 tcr = smc_read_2(sc, TCR);
1050 if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0)
1055 smc_write_2(sc, TCR, tcr);
1061 smc_mii_ifmedia_upd(struct ifnet *ifp)
1063 struct smc_softc *sc;
1064 struct mii_data *mii;
1067 if (sc->smc_miibus == NULL)
1070 mii = device_get_softc(sc->smc_miibus);
1071 return (mii_mediachg(mii));
1075 smc_mii_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
1077 struct smc_softc *sc;
1078 struct mii_data *mii;
1081 if (sc->smc_miibus == NULL)
1084 mii = device_get_softc(sc->smc_miibus);
1086 ifmr->ifm_active = mii->mii_media_active;
1087 ifmr->ifm_status = mii->mii_media_status;
1091 smc_mii_tick(void *context)
1093 struct smc_softc *sc;
1095 sc = (struct smc_softc *)context;
1097 if (sc->smc_miibus == NULL)
1102 mii_tick(device_get_softc(sc->smc_miibus));
1103 callout_reset(&sc->smc_mii_tick_ch, hz, smc_mii_tick, sc);
1107 smc_mii_mediachg(struct smc_softc *sc)
1110 if (sc->smc_miibus == NULL)
1112 mii_mediachg(device_get_softc(sc->smc_miibus));
1116 smc_mii_mediaioctl(struct smc_softc *sc, struct ifreq *ifr, u_long command)
1118 struct mii_data *mii;
1120 if (sc->smc_miibus == NULL)
1123 mii = device_get_softc(sc->smc_miibus);
1124 return (ifmedia_ioctl(sc->smc_ifp, ifr, &mii->mii_media, command));
1128 smc_reset(struct smc_softc *sc)
1132 SMC_ASSERT_LOCKED(sc);
1134 smc_select_bank(sc, 2);
1137 * Mask all interrupts.
1139 smc_write_1(sc, MSK, 0);
1142 * Tell the device to reset.
1144 smc_select_bank(sc, 0);
1145 smc_write_2(sc, RCR, RCR_SOFT_RST);
1148 * Set up the configuration register.
1150 smc_select_bank(sc, 1);
1151 smc_write_2(sc, CR, CR_EPH_POWER_EN);
1155 * Turn off transmit and receive.
1157 smc_select_bank(sc, 0);
1158 smc_write_2(sc, TCR, 0);
1159 smc_write_2(sc, RCR, 0);
1162 * Set up the control register.
1164 smc_select_bank(sc, 1);
1165 ctr = smc_read_2(sc, CTR);
1166 ctr |= CTR_LE_ENABLE | CTR_AUTO_RELEASE;
1167 smc_write_2(sc, CTR, ctr);
1172 smc_select_bank(sc, 2);
1174 smc_write_2(sc, MMUCR, MMUCR_CMD_MMU_RESET);
1178 smc_enable(struct smc_softc *sc)
1182 SMC_ASSERT_LOCKED(sc);
1186 * Set up the receive/PHY control register.
1188 smc_select_bank(sc, 0);
1189 smc_write_2(sc, RPCR, RPCR_ANEG | (RPCR_LED_LINK_ANY << RPCR_LSA_SHIFT)
1190 | (RPCR_LED_ACT_ANY << RPCR_LSB_SHIFT));
1193 * Set up the transmit and receive control registers.
1195 smc_write_2(sc, TCR, TCR_TXENA | TCR_PAD_EN);
1196 smc_write_2(sc, RCR, RCR_RXEN | RCR_STRIP_CRC);
1199 * Set up the interrupt mask.
1201 smc_select_bank(sc, 2);
1202 sc->smc_mask = EPH_INT | RX_OVRN_INT | RCV_INT | TX_INT;
1203 if ((ifp->if_capenable & IFCAP_POLLING) != 0)
1204 smc_write_1(sc, MSK, sc->smc_mask);
1208 smc_stop(struct smc_softc *sc)
1211 SMC_ASSERT_LOCKED(sc);
1214 * Turn off callouts.
1216 callout_stop(&sc->smc_watchdog);
1217 callout_stop(&sc->smc_mii_tick_ch);
1220 * Mask all interrupts.
1222 smc_select_bank(sc, 2);
1224 smc_write_1(sc, MSK, 0);
1225 #ifdef DEVICE_POLLING
1226 ether_poll_deregister(sc->smc_ifp);
1227 sc->smc_ifp->if_capenable &= ~IFCAP_POLLING;
1228 sc->smc_ifp->if_capenable &= ~IFCAP_POLLING_NOCOUNT;
1232 * Disable transmit and receive.
1234 smc_select_bank(sc, 0);
1235 smc_write_2(sc, TCR, 0);
1236 smc_write_2(sc, RCR, 0);
1238 sc->smc_ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1242 smc_watchdog(void *arg)
1244 struct smc_softc *sc;
1246 sc = (struct smc_softc *)arg;
1247 device_printf(sc->smc_dev, "watchdog timeout\n");
1248 taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_intr);
1252 smc_init(void *context)
1254 struct smc_softc *sc;
1256 sc = (struct smc_softc *)context;
1258 smc_init_locked(sc);
1263 smc_init_locked(struct smc_softc *sc)
1269 SMC_ASSERT_LOCKED(sc);
1274 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1275 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1277 smc_start_locked(ifp);
1279 if (sc->smc_mii_tick != NULL)
1280 callout_reset(&sc->smc_mii_tick_ch, hz, sc->smc_mii_tick, sc);
1282 #ifdef DEVICE_POLLING
1284 ether_poll_register(smc_poll, ifp);
1286 ifp->if_capenable |= IFCAP_POLLING;
1287 ifp->if_capenable |= IFCAP_POLLING_NOCOUNT;
1292 smc_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1294 struct smc_softc *sc;
1302 if ((ifp->if_flags & IFF_UP) == 0 &&
1303 (ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) {
1309 if (sc->smc_mii_mediachg != NULL)
1310 sc->smc_mii_mediachg(sc);
1326 if (sc->smc_mii_mediaioctl == NULL) {
1330 sc->smc_mii_mediaioctl(sc, (struct ifreq *)data, cmd);
1334 error = ether_ioctl(ifp, cmd, data);