Changeset c6f4aa6 in rtems-libbsd


Ignore:
Timestamp:
Sep 22, 2017, 7:41:20 AM (20 months ago)
Author:
Christian Mauderer <Christian.Mauderer@…>
Branches:
5cb01f277962d3127d364bf871f799b34e6b6be6, 9a4ed64d5acc20cd3488a633bd78cad7d1708081
Children:
b469163
Parents:
0190cfd
git-author:
Christian Mauderer <Christian.Mauderer@…> (09/22/17 07:41:20)
git-committer:
Sebastian Huber <sebastian.huber@…> (09/22/17 08:19:25)
Message:

if_atsam: Allow fixed MII settings.

Files:
2 added
3 edited

Legend:

Unmodified
Added
Removed
  • libbsd.py

    r0190cfd rc6f4aa6  
    162162            'sys/dev/ffec/if_ffec_mcf548x.c',
    163163            'sys/dev/atsam/if_atsam.c',
     164            'sys/dev/atsam/if_atsam_media.c',
    164165            'sys/dev/dw_mmc/dw_mmc.c',
    165166            'sys/fs/devfs/devfs_devs.c',
  • libbsd_waf.py

    r0190cfd rc6f4aa6  
    22232223              'rtemsbsd/rtems/syslog.c',
    22242224              'rtemsbsd/sys/dev/atsam/if_atsam.c',
     2225              'rtemsbsd/sys/dev/atsam/if_atsam_media.c',
    22252226              'rtemsbsd/sys/dev/dw_mmc/dw_mmc.c',
    22262227              'rtemsbsd/sys/dev/ffec/if_ffec_mcf548x.c',
  • rtemsbsd/sys/dev/atsam/if_atsam.c

    r0190cfd rc6f4aa6  
    11/*
    2  * Copyright (c) 2016 embedded brains GmbH.  All rights reserved.
     2 * Copyright (c) 2016 - 2017 embedded brains GmbH.  All rights reserved.
    33 *
    44 *  embedded brains GmbH
     
    6565#include <libchip/include/pio.h>
    6666
    67 #include <rtems/rtems_mii_ioctl.h>
    6867#include <rtems/bsd/local/miibus_if.h>
     68#include <rtems/bsd/if_atsam.h>
    6969
    7070/*
     
    130130#define TXBUF_COUNT 64
    131131#define IGNORE_RX_ERR false
    132 
    133132
    134133/** The PINs for GMAC */
     
    172171
    173172        /*
    174          * mii bus
     173         * Settings for a fixed speed.
     174         */
     175        bool fixed_speed;
     176        uint32_t media;
     177        uint32_t duplex;
     178        struct ifmedia ifmedia;
     179
     180        /*
     181         * MII bus (only used if no fixed speed)
    175182         */
    176183        device_t miibus;
     
    286293}
    287294
    288 
    289295static uint8_t if_atsam_wait_phy(Gmac *pHw, uint32_t retry)
    290296{
     
    329335        *pvalue = GMAC_PHYData(pHw);
    330336        return (0);
     337}
     338
     339
     340static int
     341if_atsam_miibus_readreg(device_t dev, int phy, int reg)
     342{
     343        uint32_t val;
     344        uint8_t err;
     345        if_atsam_softc *sc = device_get_softc(dev);
     346
     347        IF_ATSAM_LOCK(sc);
     348        err = if_atsam_read_phy(sc->Gmac_inst.gGmacd.pHw,
     349            (uint8_t)phy, (uint8_t)reg, &val, sc->Gmac_inst.retries);
     350        IF_ATSAM_UNLOCK(sc);
     351
     352        return (err == 0 ? val : 0);
     353}
     354
     355
     356static int
     357if_atsam_miibus_writereg(device_t dev, int phy, int reg, int data)
     358{
     359        uint8_t err;
     360        if_atsam_softc *sc = device_get_softc(dev);
     361
     362        IF_ATSAM_LOCK(sc);
     363        err = if_atsam_write_phy(sc->Gmac_inst.gGmacd.pHw,
     364            (uint8_t)phy, (uint8_t)reg, data, sc->Gmac_inst.retries);
     365        IF_ATSAM_UNLOCK(sc);
     366
     367        return 0;
    331368}
    332369
     
    358395        }
    359396        return (rc);
    360 }
    361 
    362 
    363 static int
    364 if_atsam_miibus_readreg(device_t dev, int phy, int reg)
    365 {
    366         uint32_t val;
    367         uint8_t err;
    368         if_atsam_softc *sc = device_get_softc(dev);
    369 
    370         IF_ATSAM_LOCK(sc);
    371         err = if_atsam_read_phy(sc->Gmac_inst.gGmacd.pHw,
    372             (uint8_t)phy, (uint8_t)reg, &val, sc->Gmac_inst.retries);
    373         IF_ATSAM_UNLOCK(sc);
    374 
    375         return (err == 0 ? val : 0);
    376 }
    377 
    378 
    379 static int
    380 if_atsam_miibus_writereg(device_t dev, int phy, int reg, int data)
    381 {
    382         uint8_t err;
    383         if_atsam_softc *sc = device_get_softc(dev);
    384 
    385         IF_ATSAM_LOCK(sc);
    386         err = if_atsam_write_phy(sc->Gmac_inst.gGmacd.pHw,
    387             (uint8_t)phy, (uint8_t)reg, data, sc->Gmac_inst.retries);
    388         IF_ATSAM_UNLOCK(sc);
    389 
    390         return 0;
    391397}
    392398
     
    822828
    823829
     830static uint8_t if_atsam_get_gmac_linkspeed_from_media(uint32_t media_subtype)
     831{
     832        switch (media_subtype) {
     833        case IFM_10_T:
     834                return GMAC_SPEED_10M;
     835                break;
     836        case IFM_100_TX:
     837                return GMAC_SPEED_100M;
     838                break;
     839        case IFM_1000_T:
     840                return GMAC_SPEED_1000M;
     841                break;
     842        default:
     843                return 0xFF;
     844                break;
     845        }
     846}
     847
     848
     849static uint8_t if_atsam_get_gmac_duplex_from_media(uint32_t media_options)
     850{
     851        if (media_options & IFM_FDX) {
     852                return GMAC_DUPLEX_FULL;
     853        } else {
     854                return GMAC_DUPLEX_HALF;
     855        }
     856}
     857
     858
    824859static void if_atsam_miibus_statchg(device_t dev)
    825860{
     
    829864        struct mii_data *mii = device_get_softc(sc->miibus);
    830865
     866        if(sc->fixed_speed)
     867                return;
     868
    831869        Gmac *pHw = sc->Gmac_inst.gGmacd.pHw;
    832870
    833         if (IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) {
    834                 link_duplex = GMAC_DUPLEX_FULL;
    835         } else {
    836                 link_duplex = GMAC_DUPLEX_HALF;
    837         }
    838 
    839         switch (IFM_SUBTYPE(mii->mii_media_active)) {
    840         case IFM_10_T:
    841                 link_speed = GMAC_SPEED_10M;
    842                 break;
    843         case IFM_100_TX:
    844                 link_speed = GMAC_SPEED_100M;
    845                 break;
    846         case IFM_1000_T:
    847                 link_speed = GMAC_SPEED_1000M;
    848                 break;
    849         default:
    850                 /* FIXME: What to do in that case? */
    851                 break;
    852         }
     871        link_duplex = if_atsam_get_gmac_duplex_from_media(
     872            IFM_OPTIONS(mii->mii_media_active));
     873
     874        link_speed = if_atsam_get_gmac_linkspeed_from_media(
     875            IFM_SUBTYPE(mii->mii_media_active));
    853876
    854877        if (sc->link_speed != link_speed || sc->link_duplex != link_duplex) {
     
    867890
    868891        sc = ifp->if_softc;
    869         if (sc->miibus == NULL)
     892        if (sc->fixed_speed || sc->miibus == NULL)
    870893                return (ENXIO);
    871894
     
    882905
    883906        sc = ifp->if_softc;
    884         if (sc->miibus == NULL)
     907        if (sc->fixed_speed || sc->miibus == NULL)
    885908                return;
    886909
     
    892915
    893916
     917static int
     918if_atsam_media_change(struct ifnet *ifp __unused)
     919{
     920        /* Do nothing. */
     921        return (0);
     922}
     923
     924
     925static void
     926if_atsam_media_status(struct ifnet *ifp, struct ifmediareq *imr)
     927{
     928        if_atsam_softc *sc = (if_atsam_softc *)ifp->if_softc;
     929
     930        imr->ifm_status = IFM_AVALID | IFM_ACTIVE;
     931        imr->ifm_active = IFM_ETHER | sc->media | sc->duplex;
     932}
     933
     934
    894935static void
    895936if_atsam_tick(void *context)
     
    901942        IF_ATSAM_UNLOCK(sc);
    902943
    903         mii_tick(device_get_softc(sc->miibus));
     944        if (!sc->fixed_speed) {
     945                mii_tick(device_get_softc(sc->miibus));
     946        }
    904947        callout_reset(&sc->tick_ch, hz, if_atsam_tick, sc);
    905948}
     
    12861329if_atsam_mediaioctl(if_atsam_softc *sc, struct ifreq *ifr, u_long command)
    12871330{
    1288         struct mii_data *mii;
    1289 
    1290         if (sc->miibus == NULL)
    1291                 return (EINVAL);
    1292 
    1293         mii = device_get_softc(sc->miibus);
    1294         return (ifmedia_ioctl(sc->ifp, ifr, &mii->mii_media, command));
     1331        if (sc->fixed_speed) {
     1332                return ifmedia_ioctl(sc->ifp, ifr, &sc->ifmedia, command);
     1333        } else {
     1334                struct mii_data *mii;
     1335
     1336                if (sc->miibus == NULL)
     1337                        return (EINVAL);
     1338
     1339                mii = device_get_softc(sc->miibus);
     1340                return (ifmedia_ioctl(sc->ifp, ifr, &mii->mii_media, command));
     1341        }
    12951342}
    12961343
     
    13541401            MTX_DEF);
    13551402
     1403        rtems_bsd_if_atsam_get_if_media_props(device_get_name(sc->dev), unit,
     1404            &sc->fixed_speed, &sc->media, &sc->duplex);
    13561405        rtems_bsd_get_mac_address(device_get_name(sc->dev), unit, eaddr);
    13571406
     
    13851434         */
    13861435        callout_init_mtx(&sc->tick_ch, &sc->mtx, CALLOUT_RETURNUNLOCKED);
    1387         mii_attach(dev, &sc->miibus, ifp,
    1388             if_atsam_mii_ifmedia_upd, if_atsam_mii_ifmedia_sts, BMSR_DEFCAPMASK,
    1389             MDIO_PHY, MII_OFFSET_ANY, 0);
     1436        if (!sc->fixed_speed) {
     1437                mii_attach(dev, &sc->miibus, ifp, if_atsam_mii_ifmedia_upd,
     1438                    if_atsam_mii_ifmedia_sts, BMSR_DEFCAPMASK,
     1439                    MDIO_PHY, MII_OFFSET_ANY, 0);
     1440        } else {
     1441                ifmedia_init(&sc->ifmedia, 0, if_atsam_media_change,
     1442                    if_atsam_media_status);
     1443                ifmedia_add(&sc->ifmedia, IFM_ETHER | sc->media
     1444                    | sc->duplex, 0, NULL);
     1445                ifmedia_set(&sc->ifmedia, IFM_ETHER | sc->media
     1446                    | sc->duplex);
     1447
     1448                GMAC_SetLinkSpeed(sc->Gmac_inst.gGmacd.pHw,
     1449                    if_atsam_get_gmac_linkspeed_from_media(sc->media),
     1450                    if_atsam_get_gmac_duplex_from_media(sc->duplex));
     1451
     1452                if_link_state_change(sc->ifp, LINK_STATE_UP);
     1453        }
    13901454
    13911455        /*
     
    14441508static devclass_t if_atsam_devclass;
    14451509DRIVER_MODULE(if_atsam, nexus, if_atsam_nexus_driver, if_atsam_devclass, 0, 0);
    1446 MODULE_DEPEND(if_atsam, miibus, 1, 1, 1);
    14471510MODULE_DEPEND(if_atsam, nexus, 1, 1, 1);
    14481511MODULE_DEPEND(if_atsam, ether, 1, 1, 1);
     1512MODULE_DEPEND(if_atsam, miibus, 1, 1, 1);
    14491513DRIVER_MODULE(miibus, if_atsam, miibus_driver, miibus_devclass, NULL, NULL);
    14501514
Note: See TracChangeset for help on using the changeset viewer.