source: rtems-libbsd/freebsd/dev/smc/if_smc.c @ 5ad09a1

4.1155-freebsd-126-freebsd-12freebsd-9.3
Last change on this file since 5ad09a1 was 5ad09a1, checked in by Joel Sherrill <joel.sherrill@…>, on 03/22/12 at 13:02:26

Add DEC Tulip, Broadcomm (bce, bfe, bge), and SMC 9111x NICs

  • Property mode set to 100644
File size: 27.8 KB
Line 
1#include <freebsd/machine/rtems-bsd-config.h>
2
3/*-
4 * Copyright (c) 2008 Benno Rice.  All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#include <freebsd/sys/cdefs.h>
28__FBSDID("$FreeBSD$");
29
30/*
31 * Driver for SMSC LAN91C111, may work for older variants.
32 */
33
34#ifdef HAVE_KERNEL_OPTION_HEADERS
35#include <freebsd/local/opt_device_polling.h>
36#endif
37
38#include <freebsd/sys/param.h>
39#include <freebsd/sys/systm.h>
40#include <freebsd/sys/errno.h>
41#include <freebsd/sys/kernel.h>
42#include <freebsd/sys/sockio.h>
43#include <freebsd/sys/malloc.h>
44#include <freebsd/sys/mbuf.h>
45#include <freebsd/sys/queue.h>
46#include <freebsd/sys/socket.h>
47#include <freebsd/sys/syslog.h>
48#include <freebsd/sys/taskqueue.h>
49
50#include <freebsd/sys/module.h>
51#include <freebsd/sys/bus.h>
52
53#include <freebsd/machine/bus.h>
54#include <freebsd/machine/resource.h>
55#include <freebsd/sys/rman.h>
56
57#include <freebsd/net/ethernet.h>
58#include <freebsd/net/if.h>
59#include <freebsd/net/if_arp.h>
60#include <freebsd/net/if_dl.h>
61#include <freebsd/net/if_types.h>
62#include <freebsd/net/if_mib.h>
63#include <freebsd/net/if_media.h>
64
65#ifdef INET
66#include <freebsd/netinet/in.h>
67#include <freebsd/netinet/in_systm.h>
68#include <freebsd/netinet/in_var.h>
69#include <freebsd/netinet/ip.h>
70#endif
71
72#include <freebsd/net/bpf.h>
73#include <freebsd/net/bpfdesc.h>
74
75#include <freebsd/dev/smc/if_smcreg.h>
76#include <freebsd/dev/smc/if_smcvar.h>
77
78#include <freebsd/dev/mii/mii.h>
79#include <freebsd/dev/mii/miivar.h>
80
81#define SMC_LOCK(sc)            mtx_lock(&(sc)->smc_mtx)
82#define SMC_UNLOCK(sc)          mtx_unlock(&(sc)->smc_mtx)
83#define SMC_ASSERT_LOCKED(sc)   mtx_assert(&(sc)->smc_mtx, MA_OWNED)
84
85#define SMC_INTR_PRIORITY       0
86#define SMC_RX_PRIORITY         5
87#define SMC_TX_PRIORITY         10
88
89devclass_t      smc_devclass;
90
91static const char *smc_chip_ids[16] = {
92        NULL, NULL, NULL,
93        /* 3 */ "SMSC LAN91C90 or LAN91C92",
94        /* 4 */ "SMSC LAN91C94",
95        /* 5 */ "SMSC LAN91C95",
96        /* 6 */ "SMSC LAN91C96",
97        /* 7 */ "SMSC LAN91C100",
98        /* 8 */ "SMSC LAN91C100FD",
99        /* 9 */ "SMSC LAN91C110FD or LAN91C111FD",
100        NULL, NULL, NULL,
101        NULL, NULL, NULL
102};
103
104static void     smc_init(void *);
105static void     smc_start(struct ifnet *);
106static void     smc_stop(struct smc_softc *);
107static int      smc_ioctl(struct ifnet *, u_long, caddr_t);
108
109static void     smc_init_locked(struct smc_softc *);
110static void     smc_start_locked(struct ifnet *);
111static void     smc_reset(struct smc_softc *);
112static int      smc_mii_ifmedia_upd(struct ifnet *);
113static void     smc_mii_ifmedia_sts(struct ifnet *, struct ifmediareq *);
114static void     smc_mii_tick(void *);
115static void     smc_mii_mediachg(struct smc_softc *);
116static int      smc_mii_mediaioctl(struct smc_softc *, struct ifreq *, u_long);
117
118static void     smc_task_intr(void *, int);
119static void     smc_task_rx(void *, int);
120static void     smc_task_tx(void *, int);
121
122static driver_filter_t  smc_intr;
123static timeout_t        smc_watchdog;
124#ifdef DEVICE_POLLING
125static poll_handler_t   smc_poll;
126#endif
127
128static __inline void
129smc_select_bank(struct smc_softc *sc, uint16_t bank)
130{
131
132        bus_write_2(sc->smc_reg, BSR, bank & BSR_BANK_MASK);
133}
134
135/* Never call this when not in bank 2. */
136static __inline void
137smc_mmu_wait(struct smc_softc *sc)
138{
139
140        KASSERT((bus_read_2(sc->smc_reg, BSR) &
141            BSR_BANK_MASK) == 2, ("%s: smc_mmu_wait called when not in bank 2",
142            device_get_nameunit(sc->smc_dev)));
143        while (bus_read_2(sc->smc_reg, MMUCR) & MMUCR_BUSY)
144                ;
145}
146
147static __inline uint8_t
148smc_read_1(struct smc_softc *sc, bus_addr_t offset)
149{
150
151        return (bus_read_1(sc->smc_reg, offset));
152}
153
154static __inline void
155smc_write_1(struct smc_softc *sc, bus_addr_t offset, uint8_t val)
156{
157
158        bus_write_1(sc->smc_reg, offset, val);
159}
160
161static __inline uint16_t
162smc_read_2(struct smc_softc *sc, bus_addr_t offset)
163{
164
165        return (bus_read_2(sc->smc_reg, offset));
166}
167
168static __inline void
169smc_write_2(struct smc_softc *sc, bus_addr_t offset, uint16_t val)
170{
171
172        bus_write_2(sc->smc_reg, offset, val);
173}
174
175static __inline void
176smc_read_multi_2(struct smc_softc *sc, bus_addr_t offset, uint16_t *datap,
177    bus_size_t count)
178{
179
180        bus_read_multi_2(sc->smc_reg, offset, datap, count);
181}
182
183static __inline void
184smc_write_multi_2(struct smc_softc *sc, bus_addr_t offset, uint16_t *datap,
185    bus_size_t count)
186{
187
188        bus_write_multi_2(sc->smc_reg, offset, datap, count);
189}
190
191int
192smc_probe(device_t dev)
193{
194        int                     rid, type, error;
195        uint16_t                val;
196        struct smc_softc        *sc;
197        struct resource         *reg;
198
199        sc = device_get_softc(dev);
200        rid = 0;
201        type = SYS_RES_IOPORT;
202        error = 0;
203
204        if (sc->smc_usemem)
205                type = SYS_RES_MEMORY;
206
207        reg = bus_alloc_resource(dev, type, &rid, 0, ~0, 16, RF_ACTIVE);
208        if (reg == NULL) {
209                if (bootverbose)
210                        device_printf(dev,
211                            "could not allocate I/O resource for probe\n");
212                return (ENXIO);
213        }
214
215        /* Check for the identification value in the BSR. */
216        val = bus_read_2(reg, BSR);
217        if ((val & BSR_IDENTIFY_MASK) != BSR_IDENTIFY) {
218                if (bootverbose)
219                        device_printf(dev, "identification value not in BSR\n");
220                error = ENXIO;
221                goto done;
222        }
223
224        /*
225         * Try switching banks and make sure we still get the identification
226         * value.
227         */
228        bus_write_2(reg, BSR, 0);
229        val = bus_read_2(reg, BSR);
230        if ((val & BSR_IDENTIFY_MASK) != BSR_IDENTIFY) {
231                if (bootverbose)
232                        device_printf(dev,
233                            "identification value not in BSR after write\n");
234                error = ENXIO;
235                goto done;
236        }
237
238#if 0
239        /* Check the BAR. */
240        bus_write_2(reg, BSR, 1);
241        val = bus_read_2(reg, BAR);
242        val = BAR_ADDRESS(val);
243        if (rman_get_start(reg) != val) {
244                if (bootverbose)
245                        device_printf(dev, "BAR address %x does not match "
246                            "I/O resource address %lx\n", val,
247                            rman_get_start(reg));
248                error = ENXIO;
249                goto done;
250        }
251#endif
252
253        /* Compare REV against known chip revisions. */
254        bus_write_2(reg, BSR, 3);
255        val = bus_read_2(reg, REV);
256        val = (val & REV_CHIP_MASK) >> REV_CHIP_SHIFT;
257        if (smc_chip_ids[val] == NULL) {
258                if (bootverbose)
259                        device_printf(dev, "Unknown chip revision: %d\n", val);
260                error = ENXIO;
261                goto done;
262        }
263
264        device_set_desc(dev, smc_chip_ids[val]);
265
266done:
267        bus_release_resource(dev, type, rid, reg);
268        return (error);
269}
270
271int
272smc_attach(device_t dev)
273{
274        int                     type, error;
275        uint16_t                val;
276        u_char                  eaddr[ETHER_ADDR_LEN];
277        struct smc_softc        *sc;
278        struct ifnet            *ifp;
279
280        sc = device_get_softc(dev);
281        error = 0;
282
283        sc->smc_dev = dev;
284
285        ifp = sc->smc_ifp = if_alloc(IFT_ETHER);
286        if (ifp == NULL) {
287                error = ENOSPC;
288                goto done;
289        }
290
291        mtx_init(&sc->smc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
292
293        /* Set up watchdog callout. */
294        callout_init_mtx(&sc->smc_watchdog, &sc->smc_mtx, 0);
295
296        type = SYS_RES_IOPORT;
297        if (sc->smc_usemem)
298                type = SYS_RES_MEMORY;
299
300        sc->smc_reg_rid = 0;
301        sc->smc_reg = bus_alloc_resource(dev, type, &sc->smc_reg_rid, 0, ~0,
302            16, RF_ACTIVE);
303        if (sc->smc_reg == NULL) {
304                error = ENXIO;
305                goto done;
306        }
307
308        sc->smc_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &sc->smc_irq_rid, 0,
309            ~0, 1, RF_ACTIVE | RF_SHAREABLE);
310        if (sc->smc_irq == NULL) {
311                error = ENXIO;
312                goto done;
313        }
314
315        SMC_LOCK(sc);
316        smc_reset(sc);
317        SMC_UNLOCK(sc);
318
319        smc_select_bank(sc, 3);
320        val = smc_read_2(sc, REV);
321        sc->smc_chip = (val & REV_CHIP_MASK) >> REV_CHIP_SHIFT;
322        sc->smc_rev = (val * REV_REV_MASK) >> REV_REV_SHIFT;
323        if (bootverbose)
324                device_printf(dev, "revision %x\n", sc->smc_rev);
325
326        callout_init_mtx(&sc->smc_mii_tick_ch, &sc->smc_mtx,
327            CALLOUT_RETURNUNLOCKED);
328        if (sc->smc_chip >= REV_CHIP_91110FD) {
329                (void)mii_attach(dev, &sc->smc_miibus, ifp,
330                    smc_mii_ifmedia_upd, smc_mii_ifmedia_sts, BMSR_DEFCAPMASK,
331                    MII_PHY_ANY, MII_OFFSET_ANY, 0);
332                if (sc->smc_miibus != NULL) {
333                        sc->smc_mii_tick = smc_mii_tick;
334                        sc->smc_mii_mediachg = smc_mii_mediachg;
335                        sc->smc_mii_mediaioctl = smc_mii_mediaioctl;
336                }
337        }
338
339        smc_select_bank(sc, 1);
340        eaddr[0] = smc_read_1(sc, IAR0);
341        eaddr[1] = smc_read_1(sc, IAR1);
342        eaddr[2] = smc_read_1(sc, IAR2);
343        eaddr[3] = smc_read_1(sc, IAR3);
344        eaddr[4] = smc_read_1(sc, IAR4);
345        eaddr[5] = smc_read_1(sc, IAR5);
346
347        if_initname(ifp, device_get_name(dev), device_get_unit(dev));
348        ifp->if_softc = sc;
349        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
350        ifp->if_init = smc_init;
351        ifp->if_ioctl = smc_ioctl;
352        ifp->if_start = smc_start;
353        IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
354        IFQ_SET_READY(&ifp->if_snd);
355
356        ifp->if_capabilities = ifp->if_capenable = 0;
357
358#ifdef DEVICE_POLLING
359        ifp->if_capabilities |= IFCAP_POLLING;
360#endif
361
362        ether_ifattach(ifp, eaddr);
363
364        /* Set up taskqueue */
365        TASK_INIT(&sc->smc_intr, SMC_INTR_PRIORITY, smc_task_intr, ifp);
366        TASK_INIT(&sc->smc_rx, SMC_RX_PRIORITY, smc_task_rx, ifp);
367        TASK_INIT(&sc->smc_tx, SMC_TX_PRIORITY, smc_task_tx, ifp);
368        sc->smc_tq = taskqueue_create_fast("smc_taskq", M_NOWAIT,
369            taskqueue_thread_enqueue, &sc->smc_tq);
370        taskqueue_start_threads(&sc->smc_tq, 1, PI_NET, "%s taskq",
371            device_get_nameunit(sc->smc_dev));
372
373        /* Mask all interrupts. */
374        sc->smc_mask = 0;
375        smc_write_1(sc, MSK, 0);
376
377        /* Wire up interrupt */
378        error = bus_setup_intr(dev, sc->smc_irq,
379            INTR_TYPE_NET|INTR_MPSAFE, smc_intr, NULL, sc, &sc->smc_ih);
380        if (error != 0)
381                goto done;
382
383done:
384        if (error != 0)
385                smc_detach(dev);
386        return (error);
387}
388
389int
390smc_detach(device_t dev)
391{
392        int                     type;
393        struct smc_softc        *sc;
394
395        sc = device_get_softc(dev);
396        SMC_LOCK(sc);
397        smc_stop(sc);
398        SMC_UNLOCK(sc);
399
400        if (sc->smc_ifp != NULL) {
401                ether_ifdetach(sc->smc_ifp);
402        }
403       
404        callout_drain(&sc->smc_watchdog);
405        callout_drain(&sc->smc_mii_tick_ch);
406       
407#ifdef DEVICE_POLLING
408        if (sc->smc_ifp->if_capenable & IFCAP_POLLING)
409                ether_poll_deregister(sc->smc_ifp);
410#endif
411
412        if (sc->smc_ih != NULL)
413                bus_teardown_intr(sc->smc_dev, sc->smc_irq, sc->smc_ih);
414
415        if (sc->smc_tq != NULL) {
416                taskqueue_drain(sc->smc_tq, &sc->smc_intr);
417                taskqueue_drain(sc->smc_tq, &sc->smc_rx);
418                taskqueue_drain(sc->smc_tq, &sc->smc_tx);
419                taskqueue_free(sc->smc_tq);
420                sc->smc_tq = NULL;
421        }
422
423        if (sc->smc_ifp != NULL) {
424                if_free(sc->smc_ifp);
425        }
426
427        if (sc->smc_miibus != NULL) {
428                device_delete_child(sc->smc_dev, sc->smc_miibus);
429                bus_generic_detach(sc->smc_dev);
430        }
431
432        if (sc->smc_reg != NULL) {
433                type = SYS_RES_IOPORT;
434                if (sc->smc_usemem)
435                        type = SYS_RES_MEMORY;
436
437                bus_release_resource(sc->smc_dev, type, sc->smc_reg_rid,
438                    sc->smc_reg);
439        }
440
441        if (sc->smc_irq != NULL)
442                bus_release_resource(sc->smc_dev, SYS_RES_IRQ, sc->smc_irq_rid,
443                   sc->smc_irq);
444
445        if (mtx_initialized(&sc->smc_mtx))
446                mtx_destroy(&sc->smc_mtx);
447
448        return (0);
449}
450
451static void
452smc_start(struct ifnet *ifp)
453{
454        struct smc_softc        *sc;
455
456        sc = ifp->if_softc;
457        SMC_LOCK(sc);
458        smc_start_locked(ifp);
459        SMC_UNLOCK(sc);
460}
461
462static void
463smc_start_locked(struct ifnet *ifp)
464{
465        struct smc_softc        *sc;
466        struct mbuf             *m;
467        u_int                   len, npages, spin_count;
468
469        sc = ifp->if_softc;
470        SMC_ASSERT_LOCKED(sc);
471
472        if (ifp->if_drv_flags & IFF_DRV_OACTIVE)
473                return;
474        if (IFQ_IS_EMPTY(&ifp->if_snd))
475                return;
476
477        /*
478         * Grab the next packet.  If it's too big, drop it.
479         */
480        IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
481        len = m_length(m, NULL);
482        len += (len & 1);
483        if (len > ETHER_MAX_LEN - ETHER_CRC_LEN) {
484                if_printf(ifp, "large packet discarded\n");
485                ++ifp->if_oerrors;
486                m_freem(m);
487                return; /* XXX readcheck? */
488        }
489
490        /*
491         * Flag that we're busy.
492         */
493        ifp->if_drv_flags |= IFF_DRV_OACTIVE;
494        sc->smc_pending = m;
495
496        /*
497         * Work out how many 256 byte "pages" we need.  We have to include the
498         * control data for the packet in this calculation.
499         */
500        npages = (len * PKT_CTRL_DATA_LEN) >> 8;
501        if (npages == 0)
502                npages = 1;
503
504        /*
505         * Request memory.
506         */
507        smc_select_bank(sc, 2);
508        smc_mmu_wait(sc);
509        smc_write_2(sc, MMUCR, MMUCR_CMD_TX_ALLOC | npages);
510
511        /*
512         * Spin briefly to see if the allocation succeeds.
513         */
514        spin_count = TX_ALLOC_WAIT_TIME;
515        do {
516                if (smc_read_1(sc, IST) & ALLOC_INT) {
517                        smc_write_1(sc, ACK, ALLOC_INT);
518                        break;
519                }
520        } while (--spin_count);
521
522        /*
523         * If the allocation is taking too long, unmask the alloc interrupt
524         * and wait.
525         */
526        if (spin_count == 0) {
527                sc->smc_mask |= ALLOC_INT;
528                if ((ifp->if_capenable & IFCAP_POLLING) == 0)
529                        smc_write_1(sc, MSK, sc->smc_mask);
530                return;
531        }
532
533        taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_tx);
534}
535
536static void
537smc_task_tx(void *context, int pending)
538{
539        struct ifnet            *ifp;
540        struct smc_softc        *sc;
541        struct mbuf             *m, *m0;
542        u_int                   packet, len;
543        uint8_t                 *data;
544
545        (void)pending;
546        ifp = (struct ifnet *)context;
547        sc = ifp->if_softc;
548
549        SMC_LOCK(sc);
550       
551        if (sc->smc_pending == NULL) {
552                SMC_UNLOCK(sc);
553                goto next_packet;
554        }
555
556        m = m0 = sc->smc_pending;
557        sc->smc_pending = NULL;
558        smc_select_bank(sc, 2);
559
560        /*
561         * Check the allocation result.
562         */
563        packet = smc_read_1(sc, ARR);
564
565        /*
566         * If the allocation failed, requeue the packet and retry.
567         */
568        if (packet & ARR_FAILED) {
569                IFQ_DRV_PREPEND(&ifp->if_snd, m);
570                ++ifp->if_oerrors;
571                ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
572                smc_start_locked(ifp);
573                SMC_UNLOCK(sc);
574                return;
575        }
576
577        /*
578         * Tell the device to write to our packet number.
579         */
580        smc_write_1(sc, PNR, packet);
581        smc_write_2(sc, PTR, 0 | PTR_AUTO_INCR);
582
583        /*
584         * Tell the device how long the packet is (including control data).
585         */
586        len = m_length(m, 0);
587        len += PKT_CTRL_DATA_LEN;
588        smc_write_2(sc, DATA0, 0);
589        smc_write_2(sc, DATA0, len);
590
591        /*
592         * Push the data out to the device.
593         */
594        data = NULL;
595        for (; m != NULL; m = m->m_next) {
596                data = mtod(m, uint8_t *);
597                smc_write_multi_2(sc, DATA0, (uint16_t *)data, m->m_len / 2);
598        }
599
600        /*
601         * Push out the control byte and and the odd byte if needed.
602         */
603        if ((len & 1) != 0 && data != NULL)
604                smc_write_2(sc, DATA0, (CTRL_ODD << 8) | data[m->m_len - 1]);
605        else
606                smc_write_2(sc, DATA0, 0);
607
608        /*
609         * Unmask the TX empty interrupt.
610         */
611        sc->smc_mask |= TX_EMPTY_INT;
612        if ((ifp->if_capenable & IFCAP_POLLING) == 0)
613                smc_write_1(sc, MSK, sc->smc_mask);
614
615        /*
616         * Enqueue the packet.
617         */
618        smc_mmu_wait(sc);
619        smc_write_2(sc, MMUCR, MMUCR_CMD_ENQUEUE);
620        callout_reset(&sc->smc_watchdog, hz * 2, smc_watchdog, sc);
621
622        /*
623         * Finish up.
624         */
625        ifp->if_opackets++;
626        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
627        SMC_UNLOCK(sc);
628        BPF_MTAP(ifp, m0);
629        m_freem(m0);
630
631next_packet:
632        /*
633         * See if there's anything else to do.
634         */
635        smc_start(ifp);
636}
637
638static void
639smc_task_rx(void *context, int pending)
640{
641        u_int                   packet, status, len;
642        uint8_t                 *data;
643        struct ifnet            *ifp;
644        struct smc_softc        *sc;
645        struct mbuf             *m, *mhead, *mtail;
646
647        (void)pending;
648        ifp = (struct ifnet *)context;
649        sc = ifp->if_softc;
650        mhead = mtail = NULL;
651
652        SMC_LOCK(sc);
653
654        packet = smc_read_1(sc, FIFO_RX);
655        while ((packet & FIFO_EMPTY) == 0) {
656                /*
657                 * Grab an mbuf and attach a cluster.
658                 */
659                MGETHDR(m, M_DONTWAIT, MT_DATA);
660                if (m == NULL) {
661                        break;
662                }
663                MCLGET(m, M_DONTWAIT);
664                if ((m->m_flags & M_EXT) == 0) {
665                        m_freem(m);
666                        break;
667                }
668       
669                /*
670                 * Point to the start of the packet.
671                 */
672                smc_select_bank(sc, 2);
673                smc_write_1(sc, PNR, packet);
674                smc_write_2(sc, PTR, 0 | PTR_READ | PTR_RCV | PTR_AUTO_INCR);
675
676                /*
677                 * Grab status and packet length.
678                 */
679                status = smc_read_2(sc, DATA0);
680                len = smc_read_2(sc, DATA0) & RX_LEN_MASK;
681                len -= 6;
682                if (status & RX_ODDFRM)
683                        len += 1;
684
685                /*
686                 * Check for errors.
687                 */
688                if (status & (RX_TOOSHORT | RX_TOOLNG | RX_BADCRC | RX_ALGNERR)) {
689                        smc_mmu_wait(sc);
690                        smc_write_2(sc, MMUCR, MMUCR_CMD_RELEASE);
691                        ifp->if_ierrors++;
692                        m_freem(m);
693                        break;
694                }
695       
696                /*
697                 * Set the mbuf up the way we want it.
698                 */
699                m->m_pkthdr.rcvif = ifp;
700                m->m_pkthdr.len = m->m_len = len + 2; /* XXX: Is this right? */
701                m_adj(m, ETHER_ALIGN);
702       
703                /*
704                 * Pull the packet out of the device.  Make sure we're in the
705                 * right bank first as things may have changed while we were
706                 * allocating our mbuf.
707                 */
708                smc_select_bank(sc, 2);
709                smc_write_1(sc, PNR, packet);
710                smc_write_2(sc, PTR, 4 | PTR_READ | PTR_RCV | PTR_AUTO_INCR);
711                data = mtod(m, uint8_t *);
712                smc_read_multi_2(sc, DATA0, (uint16_t *)data, len >> 1);
713                if (len & 1) {
714                        data += len & ~1;
715                        *data = smc_read_1(sc, DATA0);
716                }
717
718                /*
719                 * Tell the device we're done.
720                 */
721                smc_mmu_wait(sc);
722                smc_write_2(sc, MMUCR, MMUCR_CMD_RELEASE);
723                if (m == NULL) {
724                        break;
725                }
726               
727                if (mhead == NULL) {
728                        mhead = mtail = m;
729                        m->m_next = NULL;
730                } else {
731                        mtail->m_next = m;
732                        mtail = m;
733                }
734                packet = smc_read_1(sc, FIFO_RX);
735        }
736
737        sc->smc_mask |= RCV_INT;
738        if ((ifp->if_capenable & IFCAP_POLLING) == 0)
739                smc_write_1(sc, MSK, sc->smc_mask);
740
741        SMC_UNLOCK(sc);
742
743        while (mhead != NULL) {
744                m = mhead;
745                mhead = mhead->m_next;
746                m->m_next = NULL;
747                ifp->if_ipackets++;
748                (*ifp->if_input)(ifp, m);
749        }
750}
751
752#ifdef DEVICE_POLLING
753static void
754smc_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
755{
756        struct smc_softc        *sc;
757
758        sc = ifp->if_softc;
759
760        SMC_LOCK(sc);
761        if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
762                SMC_UNLOCK(sc);
763                return;
764        }
765        SMC_UNLOCK(sc);
766
767        if (cmd == POLL_AND_CHECK_STATUS)
768                taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_intr);
769}
770#endif
771
772static int
773smc_intr(void *context)
774{
775        struct smc_softc        *sc;
776       
777        sc = (struct smc_softc *)context;
778        taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_intr);
779        return (FILTER_HANDLED);
780}
781
782static void
783smc_task_intr(void *context, int pending)
784{
785        struct smc_softc        *sc;
786        struct ifnet            *ifp;
787        u_int                   status, packet, counter, tcr;
788
789        (void)pending;
790        ifp = (struct ifnet *)context;
791        sc = ifp->if_softc;
792
793        SMC_LOCK(sc);
794       
795        smc_select_bank(sc, 2);
796
797        /*
798         * Get the current mask, and then block all interrupts while we're
799         * working.
800         */
801        if ((ifp->if_capenable & IFCAP_POLLING) == 0)
802                smc_write_1(sc, MSK, 0);
803
804        /*
805         * Find out what interrupts are flagged.
806         */
807        status = smc_read_1(sc, IST) & sc->smc_mask;
808
809        /*
810         * Transmit error
811         */
812        if (status & TX_INT) {
813                /*
814                 * Kill off the packet if there is one and re-enable transmit.
815                 */
816                packet = smc_read_1(sc, FIFO_TX);
817                if ((packet & FIFO_EMPTY) == 0) {
818                        smc_write_1(sc, PNR, packet);
819                        smc_write_2(sc, PTR, 0 | PTR_READ |
820                            PTR_AUTO_INCR);
821                        tcr = smc_read_2(sc, DATA0);
822                        if ((tcr & EPHSR_TX_SUC) == 0)
823                                device_printf(sc->smc_dev,
824                                    "bad packet\n");
825                        smc_mmu_wait(sc);
826                        smc_write_2(sc, MMUCR, MMUCR_CMD_RELEASE_PKT);
827
828                        smc_select_bank(sc, 0);
829                        tcr = smc_read_2(sc, TCR);
830                        tcr |= TCR_TXENA | TCR_PAD_EN;
831                        smc_write_2(sc, TCR, tcr);
832                        smc_select_bank(sc, 2);
833                        taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_tx);
834                }
835
836                /*
837                 * Ack the interrupt.
838                 */
839                smc_write_1(sc, ACK, TX_INT);
840        }
841
842        /*
843         * Receive
844         */
845        if (status & RCV_INT) {
846                smc_write_1(sc, ACK, RCV_INT);
847                sc->smc_mask &= ~RCV_INT;
848                taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_rx);
849        }
850
851        /*
852         * Allocation
853         */
854        if (status & ALLOC_INT) {
855                smc_write_1(sc, ACK, ALLOC_INT);
856                sc->smc_mask &= ~ALLOC_INT;
857                taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_tx);
858        }
859
860        /*
861         * Receive overrun
862         */
863        if (status & RX_OVRN_INT) {
864                smc_write_1(sc, ACK, RX_OVRN_INT);
865                ifp->if_ierrors++;
866        }
867
868        /*
869         * Transmit empty
870         */
871        if (status & TX_EMPTY_INT) {
872                smc_write_1(sc, ACK, TX_EMPTY_INT);
873                sc->smc_mask &= ~TX_EMPTY_INT;
874                callout_stop(&sc->smc_watchdog);
875
876                /*
877                 * Update collision stats.
878                 */
879                smc_select_bank(sc, 0);
880                counter = smc_read_2(sc, ECR);
881                smc_select_bank(sc, 2);
882                ifp->if_collisions +=
883                    (counter & ECR_SNGLCOL_MASK) >> ECR_SNGLCOL_SHIFT;
884                ifp->if_collisions +=
885                    (counter & ECR_MULCOL_MASK) >> ECR_MULCOL_SHIFT;
886
887                /*
888                 * See if there are any packets to transmit.
889                 */
890                taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_tx);
891        }
892
893        /*
894         * Update the interrupt mask.
895         */
896        if ((ifp->if_capenable & IFCAP_POLLING) == 0)
897                smc_write_1(sc, MSK, sc->smc_mask);
898
899        SMC_UNLOCK(sc);
900}
901
902static u_int
903smc_mii_readbits(struct smc_softc *sc, int nbits)
904{
905        u_int   mgmt, mask, val;
906
907        SMC_ASSERT_LOCKED(sc);
908        KASSERT((smc_read_2(sc, BSR) & BSR_BANK_MASK) == 3,
909            ("%s: smc_mii_readbits called with bank %d (!= 3)",
910            device_get_nameunit(sc->smc_dev),
911            smc_read_2(sc, BSR) & BSR_BANK_MASK));
912
913        /*
914         * Set up the MGMT (aka MII) register.
915         */
916        mgmt = smc_read_2(sc, MGMT) & ~(MGMT_MCLK | MGMT_MDOE | MGMT_MDO);
917        smc_write_2(sc, MGMT, mgmt);
918
919        /*
920         * Read the bits in.
921         */
922        for (mask = 1 << (nbits - 1), val = 0; mask; mask >>= 1) {
923                if (smc_read_2(sc, MGMT) & MGMT_MDI)
924                        val |= mask;
925
926                smc_write_2(sc, MGMT, mgmt);
927                DELAY(1);
928                smc_write_2(sc, MGMT, mgmt | MGMT_MCLK);
929                DELAY(1);
930        }
931
932        return (val);
933}
934
935static void
936smc_mii_writebits(struct smc_softc *sc, u_int val, int nbits)
937{
938        u_int   mgmt, mask;
939
940        SMC_ASSERT_LOCKED(sc);
941        KASSERT((smc_read_2(sc, BSR) & BSR_BANK_MASK) == 3,
942            ("%s: smc_mii_writebits called with bank %d (!= 3)",
943            device_get_nameunit(sc->smc_dev),
944            smc_read_2(sc, BSR) & BSR_BANK_MASK));
945
946        /*
947         * Set up the MGMT (aka MII) register).
948         */
949        mgmt = smc_read_2(sc, MGMT) & ~(MGMT_MCLK | MGMT_MDOE | MGMT_MDO);
950        mgmt |= MGMT_MDOE;
951
952        /*
953         * Push the bits out.
954         */
955        for (mask = 1 << (nbits - 1); mask; mask >>= 1) {
956                if (val & mask)
957                        mgmt |= MGMT_MDO;
958                else
959                        mgmt &= ~MGMT_MDO;
960
961                smc_write_2(sc, MGMT, mgmt);
962                DELAY(1);
963                smc_write_2(sc, MGMT, mgmt | MGMT_MCLK);
964                DELAY(1);
965        }
966}
967
968int
969smc_miibus_readreg(device_t dev, int phy, int reg)
970{
971        struct smc_softc        *sc;
972        int                     val;
973
974        sc = device_get_softc(dev);
975
976        SMC_LOCK(sc);
977
978        smc_select_bank(sc, 3);
979
980        /*
981         * Send out the idle pattern.
982         */
983        smc_mii_writebits(sc, 0xffffffff, 32);
984
985        /*
986         * Start code + read opcode + phy address + phy register
987         */
988        smc_mii_writebits(sc, 6 << 10 | phy << 5 | reg, 14);
989
990        /*
991         * Turnaround + data
992         */
993        val = smc_mii_readbits(sc, 18);
994
995        /*
996         * Reset the MDIO interface.
997         */
998        smc_write_2(sc, MGMT,
999            smc_read_2(sc, MGMT) & ~(MGMT_MCLK | MGMT_MDOE | MGMT_MDO));
1000
1001        SMC_UNLOCK(sc);
1002        return (val);
1003}
1004
1005int
1006smc_miibus_writereg(device_t dev, int phy, int reg, int data)
1007{
1008        struct smc_softc        *sc;
1009
1010        sc = device_get_softc(dev);
1011
1012        SMC_LOCK(sc);
1013
1014        smc_select_bank(sc, 3);
1015
1016        /*
1017         * Send idle pattern.
1018         */
1019        smc_mii_writebits(sc, 0xffffffff, 32);
1020
1021        /*
1022         * Start code + write opcode + phy address + phy register + turnaround
1023         * + data.
1024         */
1025        smc_mii_writebits(sc, 5 << 28 | phy << 23 | reg << 18 | 2 << 16 | data,
1026            32);
1027
1028        /*
1029         * Reset MDIO interface.
1030         */
1031        smc_write_2(sc, MGMT,
1032            smc_read_2(sc, MGMT) & ~(MGMT_MCLK | MGMT_MDOE | MGMT_MDO));
1033
1034        SMC_UNLOCK(sc);
1035        return (0);
1036}
1037
1038void
1039smc_miibus_statchg(device_t dev)
1040{
1041        struct smc_softc        *sc;
1042        struct mii_data         *mii;
1043        uint16_t                tcr;
1044
1045        sc = device_get_softc(dev);
1046        mii = device_get_softc(sc->smc_miibus);
1047
1048        SMC_LOCK(sc);
1049
1050        smc_select_bank(sc, 0);
1051        tcr = smc_read_2(sc, TCR);
1052
1053        if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0)
1054                tcr |= TCR_SWFDUP;
1055        else
1056                tcr &= ~TCR_SWFDUP;
1057
1058        smc_write_2(sc, TCR, tcr);
1059
1060        SMC_UNLOCK(sc);
1061}
1062
1063static int
1064smc_mii_ifmedia_upd(struct ifnet *ifp)
1065{
1066        struct smc_softc        *sc;
1067        struct mii_data         *mii;
1068
1069        sc = ifp->if_softc;
1070        if (sc->smc_miibus == NULL)
1071                return (ENXIO);
1072
1073        mii = device_get_softc(sc->smc_miibus);
1074        return (mii_mediachg(mii));
1075}
1076
1077static void
1078smc_mii_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
1079{
1080        struct smc_softc        *sc;
1081        struct mii_data         *mii;
1082
1083        sc = ifp->if_softc;
1084        if (sc->smc_miibus == NULL)
1085                return;
1086
1087        mii = device_get_softc(sc->smc_miibus);
1088        mii_pollstat(mii);
1089        ifmr->ifm_active = mii->mii_media_active;
1090        ifmr->ifm_status = mii->mii_media_status;
1091}
1092
1093static void
1094smc_mii_tick(void *context)
1095{
1096        struct smc_softc        *sc;
1097
1098        sc = (struct smc_softc *)context;
1099
1100        if (sc->smc_miibus == NULL)
1101                return;
1102
1103        SMC_UNLOCK(sc);
1104
1105        mii_tick(device_get_softc(sc->smc_miibus));
1106        callout_reset(&sc->smc_mii_tick_ch, hz, smc_mii_tick, sc);
1107}
1108
1109static void
1110smc_mii_mediachg(struct smc_softc *sc)
1111{
1112
1113        if (sc->smc_miibus == NULL)
1114                return;
1115        mii_mediachg(device_get_softc(sc->smc_miibus));
1116}
1117
1118static int
1119smc_mii_mediaioctl(struct smc_softc *sc, struct ifreq *ifr, u_long command)
1120{
1121        struct mii_data *mii;
1122
1123        if (sc->smc_miibus == NULL)
1124                return (EINVAL);
1125
1126        mii = device_get_softc(sc->smc_miibus);
1127        return (ifmedia_ioctl(sc->smc_ifp, ifr, &mii->mii_media, command));
1128}
1129
1130static void
1131smc_reset(struct smc_softc *sc)
1132{
1133        u_int   ctr;
1134
1135        SMC_ASSERT_LOCKED(sc);
1136
1137        smc_select_bank(sc, 2);
1138
1139        /*
1140         * Mask all interrupts.
1141         */
1142        smc_write_1(sc, MSK, 0);
1143
1144        /*
1145         * Tell the device to reset.
1146         */
1147        smc_select_bank(sc, 0);
1148        smc_write_2(sc, RCR, RCR_SOFT_RST);
1149
1150        /*
1151         * Set up the configuration register.
1152         */
1153        smc_select_bank(sc, 1);
1154        smc_write_2(sc, CR, CR_EPH_POWER_EN);
1155        DELAY(1);
1156
1157        /*
1158         * Turn off transmit and receive.
1159         */
1160        smc_select_bank(sc, 0);
1161        smc_write_2(sc, TCR, 0);
1162        smc_write_2(sc, RCR, 0);
1163
1164        /*
1165         * Set up the control register.
1166         */
1167        smc_select_bank(sc, 1);
1168        ctr = smc_read_2(sc, CTR);
1169        ctr |= CTR_LE_ENABLE | CTR_AUTO_RELEASE;
1170        smc_write_2(sc, CTR, ctr);
1171
1172        /*
1173         * Reset the MMU.
1174         */
1175        smc_select_bank(sc, 2);
1176        smc_mmu_wait(sc);
1177        smc_write_2(sc, MMUCR, MMUCR_CMD_MMU_RESET);
1178}
1179
1180static void
1181smc_enable(struct smc_softc *sc)
1182{
1183        struct ifnet            *ifp;
1184
1185        SMC_ASSERT_LOCKED(sc);
1186        ifp = sc->smc_ifp;
1187
1188        /*
1189         * Set up the receive/PHY control register.
1190         */
1191        smc_select_bank(sc, 0);
1192        smc_write_2(sc, RPCR, RPCR_ANEG | (RPCR_LED_LINK_ANY << RPCR_LSA_SHIFT)
1193            | (RPCR_LED_ACT_ANY << RPCR_LSB_SHIFT));
1194
1195        /*
1196         * Set up the transmit and receive control registers.
1197         */
1198        smc_write_2(sc, TCR, TCR_TXENA | TCR_PAD_EN);
1199        smc_write_2(sc, RCR, RCR_RXEN | RCR_STRIP_CRC);
1200
1201        /*
1202         * Set up the interrupt mask.
1203         */
1204        smc_select_bank(sc, 2);
1205        sc->smc_mask = EPH_INT | RX_OVRN_INT | RCV_INT | TX_INT;
1206        if ((ifp->if_capenable & IFCAP_POLLING) != 0)
1207                smc_write_1(sc, MSK, sc->smc_mask);
1208}
1209
1210static void
1211smc_stop(struct smc_softc *sc)
1212{
1213
1214        SMC_ASSERT_LOCKED(sc);
1215
1216        /*
1217         * Turn off callouts.
1218         */
1219        callout_stop(&sc->smc_watchdog);
1220        callout_stop(&sc->smc_mii_tick_ch);
1221
1222        /*
1223         * Mask all interrupts.
1224         */
1225        smc_select_bank(sc, 2);
1226        sc->smc_mask = 0;
1227        smc_write_1(sc, MSK, 0);
1228#ifdef DEVICE_POLLING
1229        ether_poll_deregister(sc->smc_ifp);
1230        sc->smc_ifp->if_capenable &= ~IFCAP_POLLING;
1231        sc->smc_ifp->if_capenable &= ~IFCAP_POLLING_NOCOUNT;
1232#endif
1233
1234        /*
1235         * Disable transmit and receive.
1236         */
1237        smc_select_bank(sc, 0);
1238        smc_write_2(sc, TCR, 0);
1239        smc_write_2(sc, RCR, 0);
1240
1241        sc->smc_ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1242}
1243
1244static void
1245smc_watchdog(void *arg)
1246{
1247        struct smc_softc        *sc;
1248       
1249        sc = (struct smc_softc *)arg;
1250        device_printf(sc->smc_dev, "watchdog timeout\n");
1251        taskqueue_enqueue_fast(sc->smc_tq, &sc->smc_intr);
1252}
1253
1254static void
1255smc_init(void *context)
1256{
1257        struct smc_softc        *sc;
1258
1259        sc = (struct smc_softc *)context;
1260        SMC_LOCK(sc);
1261        smc_init_locked(sc);
1262        SMC_UNLOCK(sc);
1263}
1264
1265static void
1266smc_init_locked(struct smc_softc *sc)
1267{
1268        struct ifnet    *ifp;
1269
1270        ifp = sc->smc_ifp;
1271
1272        SMC_ASSERT_LOCKED(sc);
1273
1274        smc_reset(sc);
1275        smc_enable(sc);
1276
1277        ifp->if_drv_flags |= IFF_DRV_RUNNING;
1278        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1279
1280        smc_start_locked(ifp);
1281
1282        if (sc->smc_mii_tick != NULL)
1283                callout_reset(&sc->smc_mii_tick_ch, hz, sc->smc_mii_tick, sc);
1284
1285#ifdef DEVICE_POLLING
1286        SMC_UNLOCK(sc);
1287        ether_poll_register(smc_poll, ifp);
1288        SMC_LOCK(sc);
1289        ifp->if_capenable |= IFCAP_POLLING;
1290        ifp->if_capenable |= IFCAP_POLLING_NOCOUNT;
1291#endif
1292}
1293
1294static int
1295smc_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1296{
1297        struct smc_softc        *sc;
1298        int                     error;
1299
1300        sc = ifp->if_softc;
1301        error = 0;
1302
1303        switch (cmd) {
1304        case SIOCSIFFLAGS:
1305                if ((ifp->if_flags & IFF_UP) == 0 &&
1306                    (ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) {
1307                        SMC_LOCK(sc);
1308                        smc_stop(sc);
1309                        SMC_UNLOCK(sc);
1310                } else {
1311                        smc_init(sc);
1312                        if (sc->smc_mii_mediachg != NULL)
1313                                sc->smc_mii_mediachg(sc);
1314                }
1315                break;
1316
1317        case SIOCADDMULTI:
1318        case SIOCDELMULTI:
1319                /* XXX
1320                SMC_LOCK(sc);
1321                smc_setmcast(sc);
1322                SMC_UNLOCK(sc);
1323                */
1324                error = EINVAL;
1325                break;
1326
1327        case SIOCGIFMEDIA:
1328        case SIOCSIFMEDIA:
1329                if (sc->smc_mii_mediaioctl == NULL) {
1330                        error = EINVAL;
1331                        break;
1332                }
1333                sc->smc_mii_mediaioctl(sc, (struct ifreq *)data, cmd);
1334                break;
1335
1336        default:
1337                error = ether_ioctl(ifp, cmd, data);
1338                break;
1339        }
1340
1341        return (error);
1342}
Note: See TracBrowser for help on using the repository browser.