Changeset 0c24e06 in rtems-libbsd


Ignore:
Timestamp:
Aug 23, 2016, 12:22:26 PM (3 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
5283630d2c9d40deb0183696d278e02644fe4326, freebsd-9.3, bc2ba9a9cdc7381c2a4f2ae6ee303be636f31368
Children:
7c77211
Parents:
a971614
git-author:
Sebastian Huber <sebastian.huber@…> (08/23/16 12:22:26)
git-committer:
Sebastian Huber <sebastian.huber@…> (08/23/16 13:18:42)
Message:

mmc: Update to FreeBSD trunk 2016-08-23

Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • freebsd/sys/dev/mmc/bridge.h

    ra971614 r0c24e06  
    5454#ifndef DEV_MMC_BRIDGE_H
    5555#define DEV_MMC_BRIDGE_H
     56
     57#include <sys/bus.h>
    5658
    5759/*
     
    136138};
    137139
     140extern driver_t   mmc_driver;
     141extern devclass_t mmc_devclass;
     142
    138143#endif /* DEV_MMC_BRIDGE_H */
  • freebsd/sys/dev/mmc/mmc.c

    ra971614 r0c24e06  
    6666#include <sys/endian.h>
    6767#include <sys/sysctl.h>
     68#include <sys/time.h>
    6869
    6970#include <dev/mmc/mmcreg.h>
     
    7980        device_t owner;
    8081        uint32_t last_rca;
     82        int      squelched; /* suppress reporting of (expected) errors */
     83        int      log_count;
     84        struct timeval log_time;
    8185};
     86
     87#define LOG_PPS         5 /* Log no more than 5 errors per second. */
    8288
    8389/*
     
    105111        uint32_t erase_sector;  /* Card native erase sector size */
    106112        char card_id_string[64];/* Formatted CID info (serial, MFG, etc) */
     113        char card_sn_string[16];/* Formatted serial # for disk->d_ident */
    107114};
    108115
    109116#define CMD_RETRIES     3
    110117
     118#define CARD_ID_FREQUENCY 400000 /* Spec requires 400kHz max during ID phase. */
     119
    111120static SYSCTL_NODE(_hw, OID_AUTO, mmc, CTLFLAG_RD, NULL, "mmc driver");
    112121
    113122static int mmc_debug;
    114 SYSCTL_INT(_hw_mmc, OID_AUTO, debug, CTLFLAG_RW, &mmc_debug, 0, "Debug level");
     123SYSCTL_INT(_hw_mmc, OID_AUTO, debug, CTLFLAG_RWTUN, &mmc_debug, 0, "Debug level");
    115124
    116125/* bus entry points */
     
    356365        int i;
    357366
    358         for (i = 30; i >= 0; i--)
     367        for (i = MMC_OCR_MAX_VOLTAGE_SHIFT;
     368            i >= MMC_OCR_MIN_VOLTAGE_SHIFT; i--)
    359369                if (ocr & (1 << i))
    360370                        return (i);
     
    393403                msleep(req, &sc->sc_mtx, 0, "mmcreq", 0);
    394404        MMC_UNLOCK(sc);
    395         if (mmc_debug > 2 || (mmc_debug > 1 && req->cmd->error))
    396                 device_printf(sc->dev, "RESULT: %d\n", req->cmd->error);
     405        if (mmc_debug > 2 || (mmc_debug > 0 && req->cmd->error != MMC_ERR_NONE))
     406                device_printf(sc->dev, "CMD%d RESULT: %d\n",
     407                    req->cmd->opcode, req->cmd->error);
    397408        return (0);
    398409}
     
    410421{
    411422        struct mmc_request mreq;
    412 
    413         memset(&mreq, 0, sizeof(mreq));
    414         memset(cmd->resp, 0, sizeof(cmd->resp));
    415         cmd->retries = retries;
    416         mreq.cmd = cmd;
    417         mmc_wait_for_req(sc, &mreq);
    418         return (cmd->error);
     423        int err;
     424
     425        do {
     426                memset(&mreq, 0, sizeof(mreq));
     427                memset(cmd->resp, 0, sizeof(cmd->resp));
     428                cmd->retries = 0; /* Retries done here, not in hardware. */
     429                cmd->mrq = &mreq;
     430                mreq.cmd = cmd;
     431                if (mmc_wait_for_req(sc, &mreq) != 0)
     432                        err = MMC_ERR_FAILED;
     433                else
     434                        err = cmd->error;
     435        } while (err != MMC_ERR_NONE && retries-- > 0);
     436
     437        if (err != MMC_ERR_NONE && sc->squelched == 0) {
     438                if (ppsratecheck(&sc->log_time, &sc->log_count, LOG_PPS)) {
     439                        device_printf(sc->dev, "CMD%d failed, RESULT: %d\n",
     440                            cmd->opcode, err);
     441                }
     442        }
     443
     444        return (err);
    419445}
    420446
     
    424450{
    425451        struct mmc_command appcmd;
    426         int err = MMC_ERR_NONE, i;
    427 
    428         for (i = 0; i <= retries; i++) {
     452        int err;
     453
     454        /* Squelch error reporting at lower levels, we report below. */
     455        sc->squelched++;
     456        do {
     457                memset(&appcmd, 0, sizeof(appcmd));
    429458                appcmd.opcode = MMC_APP_CMD;
    430459                appcmd.arg = rca << 16;
    431460                appcmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
    432461                appcmd.data = NULL;
    433                 mmc_wait_for_cmd(sc, &appcmd, 0);
    434                 err = appcmd.error;
    435                 if (err != MMC_ERR_NONE)
    436                         continue;
    437                 if (!(appcmd.resp[0] & R1_APP_CMD))
    438                         return MMC_ERR_FAILED;
    439                 mmc_wait_for_cmd(sc, cmd, 0);
    440                 err = cmd->error;
    441                 if (err == MMC_ERR_NONE)
    442                         break;
    443         }
     462                if (mmc_wait_for_cmd(sc, &appcmd, 0) != 0)
     463                        err = MMC_ERR_FAILED;
     464                else
     465                        err = appcmd.error;
     466                if (err == MMC_ERR_NONE) {
     467                        if (!(appcmd.resp[0] & R1_APP_CMD))
     468                                err = MMC_ERR_FAILED;
     469                        else if (mmc_wait_for_cmd(sc, cmd, 0) != 0)
     470                                err = MMC_ERR_FAILED;
     471                        else
     472                                err = cmd->error;
     473                }
     474        } while (err != MMC_ERR_NONE && retries-- > 0);
     475        sc->squelched--;
     476
     477        if (err != MMC_ERR_NONE && sc->squelched == 0) {
     478                if (ppsratecheck(&sc->log_time, &sc->log_count, LOG_PPS)) {
     479                        device_printf(sc->dev, "ACMD%d failed, RESULT: %d\n",
     480                            cmd->opcode, err);
     481                }
     482        }
     483
    444484        return (err);
    445485}
     
    460500        if (err)
    461501                return (err);
    462         if (cmd.error)
    463                 return (cmd.error);
    464502        if (resp) {
    465503                if (flags & MMC_RSP_136)
     
    487525        cmd.flags = MMC_RSP_NONE | MMC_CMD_BC;
    488526        cmd.data = NULL;
    489         mmc_wait_for_cmd(sc, &cmd, 0);
     527        mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
    490528        mmc_ms_delay(1);
    491529
     
    580618        mmc_ms_delay(1);
    581619
    582         mmcbr_set_clock(dev, mmcbr_get_f_min(sc->dev));
     620        mmcbr_set_clock(dev, CARD_ID_FREQUENCY);
    583621        mmcbr_set_timing(dev, bus_timing_normal);
    584622        mmcbr_set_power_mode(dev, power_on);
     
    617655        int err;
    618656
     657        memset(&cmd, 0, sizeof(cmd));
    619658        cmd.opcode = MMC_SWITCH_FUNC;
    620659        cmd.arg = (MMC_SWITCH_FUNC_WR << 24) |
     
    624663        cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
    625664        cmd.data = NULL;
    626         err = mmc_wait_for_cmd(sc, &cmd, 0);
     665        err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
    627666        return (err);
    628667}
     
    636675        struct mmc_data data;
    637676
    638         memset(&cmd, 0, sizeof(struct mmc_command));
    639         memset(&data, 0, sizeof(struct mmc_data));
     677        memset(&cmd, 0, sizeof(cmd));
     678        memset(&data, 0, sizeof(data));
    640679        memset(res, 0, 64);
    641680
     
    664703
    665704        if (mmcbr_get_mode(sc->dev) == mode_sd) {
    666                 memset(&cmd, 0, sizeof(struct mmc_command));
     705                memset(&cmd, 0, sizeof(cmd));
    667706                cmd.opcode = ACMD_SET_CLR_CARD_DETECT;
    668707                cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
     
    671710                if (err != 0)
    672711                        return (err);
    673                 memset(&cmd, 0, sizeof(struct mmc_command));
     712                memset(&cmd, 0, sizeof(cmd));
    674713                cmd.opcode = ACMD_SET_BUS_WIDTH;
    675714                cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
     
    747786                mmcbr_update_ios(sc->dev);
    748787
     788                sc->squelched++; /* Errors are expected, squelch reporting. */
     789                memset(&cmd, 0, sizeof(cmd));
     790                memset(&data, 0, sizeof(data));
    749791                cmd.opcode = MMC_BUSTEST_W;
    750792                cmd.arg = 0;
     
    757799                mmc_wait_for_cmd(sc, &cmd, 0);
    758800               
     801                memset(&cmd, 0, sizeof(cmd));
     802                memset(&data, 0, sizeof(data));
    759803                cmd.opcode = MMC_BUSTEST_R;
    760804                cmd.arg = 0;
     
    766810                data.flags = MMC_DATA_READ;
    767811                err = mmc_wait_for_cmd(sc, &cmd, 0);
     812                sc->squelched--;
    768813               
    769814                mmcbr_set_bus_width(sc->dev, bus_width_1);
     
    778823                mmcbr_update_ios(sc->dev);
    779824
     825                sc->squelched++; /* Errors are expected, squelch reporting. */
     826                memset(&cmd, 0, sizeof(cmd));
     827                memset(&data, 0, sizeof(data));
    780828                cmd.opcode = MMC_BUSTEST_W;
    781829                cmd.arg = 0;
     
    788836                mmc_wait_for_cmd(sc, &cmd, 0);
    789837               
     838                memset(&cmd, 0, sizeof(cmd));
     839                memset(&data, 0, sizeof(data));
    790840                cmd.opcode = MMC_BUSTEST_R;
    791841                cmd.arg = 0;
     
    797847                data.flags = MMC_DATA_READ;
    798848                err = mmc_wait_for_cmd(sc, &cmd, 0);
     849                sc->squelched--;
    799850
    800851                mmcbr_set_bus_width(sc->dev, bus_width_1);
     
    866917         * mmcsd0: 968MB <SD SD01G 8.0 SN 2686905 Mfg 08/2008 by 3 TN> at mmc0
    867918         * 22.5MHz/4bit/128-block
     919         *
     920         * Also format just the card serial number, which the mmcsd driver will
     921         * use as the disk->d_ident string.
    868922         *
    869923         * The card_id_string in mmc_ivars is currently allocated as 64 bytes,
     
    880934        else
    881935                snprintf(oidstr, sizeof(oidstr), "0x%04x", ivar->cid.oid);
     936        snprintf(ivar->card_sn_string, sizeof(ivar->card_sn_string),
     937            "%08X", ivar->cid.psn);
    882938        snprintf(ivar->card_id_string, sizeof(ivar->card_id_string),
    883             "%s%s %s %d.%d SN %u MFG %02d/%04d by %d %s",
     939            "%s%s %s %d.%d SN %08X MFG %02d/%04d by %d %s",
    884940            ivar->mode == mode_sd ? "SD" : "MMC", ivar->high_cap ? "HC" : "",
    885941            ivar->cid.pnm, ivar->cid.prv >> 4, ivar->cid.prv & 0x0f,
     
    10491105        int err;
    10501106
     1107        memset(&cmd, 0, sizeof(cmd));
    10511108        cmd.opcode = MMC_ALL_SEND_CID;
    10521109        cmd.arg = 0;
    10531110        cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
    10541111        cmd.data = NULL;
    1055         err = mmc_wait_for_cmd(sc, &cmd, 0);
     1112        err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
    10561113        memcpy(rawcid, cmd.resp, 4 * sizeof(uint32_t));
    10571114        return (err);
     
    10641121        int err;
    10651122
     1123        memset(&cmd, 0, sizeof(cmd));
    10661124        cmd.opcode = MMC_SEND_CSD;
    10671125        cmd.arg = rca << 16;
    10681126        cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
    10691127        cmd.data = NULL;
    1070         err = mmc_wait_for_cmd(sc, &cmd, 0);
     1128        err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
    10711129        memcpy(rawcsd, cmd.resp, 4 * sizeof(uint32_t));
    10721130        return (err);
     
    10801138        struct mmc_data data;
    10811139
    1082         memset(&cmd, 0, sizeof(struct mmc_command));
    1083         memset(&data, 0, sizeof(struct mmc_data));
     1140        memset(&cmd, 0, sizeof(cmd));
     1141        memset(&data, 0, sizeof(data));
    10841142
    10851143        memset(rawscr, 0, 8);
     
    11061164        struct mmc_data data;
    11071165
    1108         memset(&cmd, 0, sizeof(struct mmc_command));
    1109         memset(&data, 0, sizeof(struct mmc_data));
     1166        memset(&cmd, 0, sizeof(cmd));
     1167        memset(&data, 0, sizeof(data));
    11101168
    11111169        memset(rawextcsd, 0, 512);
     
    11301188        struct mmc_data data;
    11311189
    1132         memset(&cmd, 0, sizeof(struct mmc_command));
    1133         memset(&data, 0, sizeof(struct mmc_data));
     1190        memset(&cmd, 0, sizeof(cmd));
     1191        memset(&data, 0, sizeof(data));
    11341192
    11351193        memset(rawsdstatus, 0, 64);
     
    11551213        int err;
    11561214
     1215        memset(&cmd, 0, sizeof(cmd));
    11571216        cmd.opcode = MMC_SET_RELATIVE_ADDR;
    11581217        cmd.arg = resp << 16;
    11591218        cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
    11601219        cmd.data = NULL;
    1161         err = mmc_wait_for_cmd(sc, &cmd, 0);
     1220        err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
    11621221        return (err);
    11631222}
     
    11691228        int err;
    11701229
     1230        memset(&cmd, 0, sizeof(cmd));
    11711231        cmd.opcode = SD_SEND_RELATIVE_ADDR;
    11721232        cmd.arg = 0;
    11731233        cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
    11741234        cmd.data = NULL;
    1175         err = mmc_wait_for_cmd(sc, &cmd, 0);
     1235        err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
    11761236        *resp = cmd.resp[0];
    11771237        return (err);
     
    11841244        int err;
    11851245
     1246        memset(&cmd, 0, sizeof(cmd));
    11861247        cmd.opcode = MMC_SEND_STATUS;
    11871248        cmd.arg = rca << 16;
    11881249        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
    11891250        cmd.data = NULL;
    1190         err = mmc_wait_for_cmd(sc, &cmd, 0);
     1251        err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
    11911252        *status = cmd.resp[0];
    11921253        return (err);
     
    11991260        int err;
    12001261
     1262        memset(&cmd, 0, sizeof(cmd));
    12011263        cmd.opcode = MMC_SET_BLOCKLEN;
    12021264        cmd.arg = len;
    12031265        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
    12041266        cmd.data = NULL;
    1205         err = mmc_wait_for_cmd(sc, &cmd, 0);
     1267        err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
    12061268        return (err);
    12071269}
     
    12101272mmc_log_card(device_t dev, struct mmc_ivars *ivar, int newcard)
    12111273{
    1212         device_printf(dev, "Card at relative address %d%s:\n",
     1274        device_printf(dev, "Card at relative address 0x%04x%s:\n",
    12131275            ivar->rca, newcard ? " added" : "");
    12141276        device_printf(dev, " card: %s\n", ivar->card_id_string);
     
    12381300                device_printf(sc->dev, "Probing cards\n");
    12391301        while (1) {
     1302                sc->squelched++; /* Errors are expected, squelch reporting. */
    12401303                err = mmc_all_send_cid(sc, raw_cid);
     1304                sc->squelched--;
    12411305                if (err == MMC_ERR_TIMEOUT)
    12421306                        break;
     
    12641328                        ivar = malloc(sizeof(struct mmc_ivars), M_DEVBUF,
    12651329                            M_WAITOK | M_ZERO);
    1266                         if (!ivar)
    1267                                 return;
    12681330                        memcpy(ivar->raw_cid, raw_cid, sizeof(raw_cid));
    12691331                }
     
    13201382                                }
    13211383                        }
     1384
     1385                        /*
     1386                         * We deselect then reselect the card here.  Some cards
     1387                         * become unselected and timeout with the above two
     1388                         * commands, although the state tables / diagrams in the
     1389                         * standard suggest they go back to the transfer state.
     1390                         * Other cards don't become deselected, and if we
     1391                         * atttempt to blindly re-select them, we get timeout
     1392                         * errors from some controllers.  So we deselect then
     1393                         * reselect to handle all situations.  The only thing we
     1394                         * use from the sd_status is the erase sector size, but
     1395                         * it is still nice to get that right.
     1396                         */
     1397                        mmc_select_card(sc, 0);
     1398                        mmc_select_card(sc, ivar->rca);
    13221399                        mmc_app_sd_status(sc, ivar->rca, ivar->raw_sd_status);
    13231400                        mmc_app_decode_sd_status(ivar->raw_sd_status,
     
    13271404                                    16 << ivar->sd_status.au_size;
    13281405                        }
    1329                         mmc_select_card(sc, 0);
    13301406                        /* Find max supported bus width. */
    13311407                        if ((mmcbr_get_caps(sc->dev) & MMC_CAP_4_BIT_DATA) &&
     
    13551431                                device_set_ivars(child, ivar);
    13561432                        }
     1433                        mmc_select_card(sc, 0);
    13571434                        return;
    13581435                }
     
    13871464                }
    13881465
     1466                mmc_select_card(sc, ivar->rca);
     1467
    13891468                /* Only MMC >= 4.x cards support EXT_CSD. */
    13901469                if (ivar->csd.spec_vers >= 4) {
    1391                         /* Card must be selected to fetch EXT_CSD. */
    1392                         mmc_select_card(sc, ivar->rca);
    13931470                        mmc_send_ext_csd(sc, ivar->raw_ext_csd);
    13941471                        /* Handle extended capacity from EXT_CSD */
     
    14131490                        /* Find max supported bus width. */
    14141491                        ivar->bus_width = mmc_test_bus_width(sc);
    1415                         mmc_select_card(sc, 0);
    14161492                        /* Handle HC erase sector size. */
    14171493                        if (ivar->raw_ext_csd[EXT_CSD_ERASE_GRP_SIZE] != 0) {
     
    14471523                        device_set_ivars(child, ivar);
    14481524                }
     1525                mmc_select_card(sc, 0);
    14491526        }
    14501527}
     
    15061583                 * First, try SD modes
    15071584                 */
     1585                sc->squelched++; /* Errors are expected, squelch reporting. */
    15081586                mmcbr_set_mode(dev, mode_sd);
    15091587                mmc_power_up(sc);
     
    15311609                } else if (bootverbose || mmc_debug)
    15321610                        device_printf(sc->dev, "SD probe: OK (OCR: 0x%08x)\n", ocr);
     1611                sc->squelched--;
    15331612
    15341613                mmcbr_set_ocr(dev, mmc_select_vdd(sc, ocr));
     
    15371616        } else {
    15381617                mmcbr_set_bus_mode(dev, opendrain);
    1539                 mmcbr_set_clock(dev, mmcbr_get_f_min(dev));
     1618                mmcbr_set_clock(dev, CARD_ID_FREQUENCY);
    15401619                mmcbr_update_ios(dev);
    15411620                /* XXX recompute vdd based on new cards? */
     
    15481627                device_printf(sc->dev, "Current OCR: 0x%08x\n", mmcbr_get_ocr(dev));
    15491628        if (mmcbr_get_ocr(dev) == 0) {
     1629                device_printf(sc->dev, "No compatible cards found on bus\n");
    15501630                mmc_delete_cards(sc);
    15511631                mmc_power_down(sc);
     
    15601640                    (err ? 0 : MMC_OCR_CCS) | mmcbr_get_ocr(dev), NULL);
    15611641        } else
    1562                 mmc_send_op_cond(sc, mmcbr_get_ocr(dev), NULL);
     1642                mmc_send_op_cond(sc, MMC_OCR_CCS | mmcbr_get_ocr(dev), NULL);
    15631643        mmc_discover_cards(sc);
    15641644        mmc_rescan_cards(sc);
     
    15751655{
    15761656        int max_dtr, max_hs_dtr, max_timing;
    1577         int nkid, i, f_min, f_max;
     1657        int nkid, i, f_max;
    15781658        device_t *kids;
    15791659        struct mmc_ivars *ivar;
    15801660       
    1581         f_min = mmcbr_get_f_min(sc->dev);
    15821661        f_max = mmcbr_get_f_max(sc->dev);
    15831662        max_dtr = max_hs_dtr = f_max;
     
    16741753                *(char **)result = ivar->card_id_string;
    16751754                break;
     1755        case MMC_IVAR_CARD_SN_STRING:
     1756                *(char **)result = ivar->card_sn_string;
     1757                break;
    16761758        }
    16771759        return (0);
     
    17261808};
    17271809
    1728 static driver_t mmc_driver = {
     1810driver_t mmc_driver = {
    17291811        "mmc",
    17301812        mmc_methods,
    17311813        sizeof(struct mmc_softc),
    17321814};
    1733 static devclass_t mmc_devclass;
    1734 
    1735 DRIVER_MODULE(mmc, at91_mci, mmc_driver, mmc_devclass, NULL, NULL);
    1736 DRIVER_MODULE(mmc, dw_mmc, mmc_driver, mmc_devclass, NULL, NULL);
    1737 DRIVER_MODULE(mmc, sdhci, mmc_driver, mmc_devclass, NULL, NULL);
     1815devclass_t mmc_devclass;
     1816
     1817MODULE_VERSION(mmc, 1);
  • freebsd/sys/dev/mmc/mmcreg.h

    ra971614 r0c24e06  
    8686#define MMC_RSP_R2      (MMC_RSP_PRESENT | MMC_RSP_136 | MMC_RSP_CRC)
    8787#define MMC_RSP_R3      (MMC_RSP_PRESENT)
    88 #define MMC_RSP_R6      (MMC_RSP_PRESENT | MMC_RSP_CRC)
    89 #define MMC_RSP_R7      (MMC_RSP_PRESENT | MMC_RSP_CRC)
     88#define MMC_RSP_R4      (MMC_RSP_PRESENT)
     89#define MMC_RSP_R5      (MMC_RSP_PRESENT | MMC_RSP_CRC | MMC_RSP_OPCODE)
     90#define MMC_RSP_R5B     (MMC_RSP_PRESENT | MMC_RSP_CRC | MMC_RSP_OPCODE | MMC_RSP_BUSY)
     91#define MMC_RSP_R6      (MMC_RSP_PRESENT | MMC_RSP_CRC | MMC_RSP_OPCODE)
     92#define MMC_RSP_R7      (MMC_RSP_PRESENT | MMC_RSP_CRC | MMC_RSP_OPCODE)
    9093#define MMC_RSP(x)      ((x) & MMC_RSP_MASK)
    9194        uint32_t        retries;
     
    354357#define MMC_OCR_LOW_VOLTAGE (1u << 7)   /* Low Voltage Range -- tbd */
    355358#define MMC_OCR_200_210 (1U << 8)       /* Vdd voltage 2.00 ~ 2.10 */
     359#define MMC_OCR_MIN_VOLTAGE_SHIFT       8
    356360#define MMC_OCR_210_220 (1U << 9)       /* Vdd voltage 2.10 ~ 2.20 */
    357361#define MMC_OCR_220_230 (1U << 10)      /* Vdd voltage 2.20 ~ 2.30 */
     
    369373#define MMC_OCR_340_350 (1U << 22)      /* Vdd voltage 3.40 ~ 3.50 */
    370374#define MMC_OCR_350_360 (1U << 23)      /* Vdd voltage 3.50 ~ 3.60 */
     375#define MMC_OCR_MAX_VOLTAGE_SHIFT       23
    371376#define MMC_OCR_CCS     (1u << 30)      /* Card Capacity status (SD vs SDHC) */
    372377#define MMC_OCR_CARD_BUSY (1U << 31)    /* Card Power up status */
     
    437442 * I've been able to find no old MMC or SD cards that have a non 512
    438443 * byte sector size anywhere, so we assume that such cards are very rare
    439  * and only note their existance in passing here...
     444 * and only note their existence in passing here...
    440445 */
    441446#define MMC_SECTOR_SIZE 512
  • freebsd/sys/dev/mmc/mmcsd.c

    ra971614 r0c24e06  
    6767#include <sys/module.h>
    6868#include <sys/mutex.h>
     69#include <sys/time.h>
     70#include <geom/geom.h>
    6971#include <geom/geom_disk.h>
    7072
     
    9799        int running;
    98100        int suspend;
     101        int log_count;
     102        struct timeval log_time;
    99103#endif /* __rtems__ */
    100104};
     105
     106#ifndef __rtems__
     107static const char *errmsg[] =
     108{
     109        "None",
     110        "Timeout",
     111        "Bad CRC",
     112        "Fifo",
     113        "Failed",
     114        "Invalid",
     115        "NO MEMORY"
     116};
     117#endif /* __rtems__ */
     118
     119#define LOG_PPS         5 /* Log no more than 5 errors per second. */
    101120
    102121/* bus entry points */
     
    348367#ifndef __rtems__
    349368        struct disk *d;
     369#else /* __rtems__ */
     370        struct {
     371                char d_ident[16];
     372                char d_descr[64];
     373        } x, *d = &x;
    350374#endif /* __rtems__ */
    351375        intmax_t mb;
     
    366390        d->d_name = "mmcsd";
    367391        d->d_drv1 = sc;
    368         d->d_maxsize = 4*1024*1024;     /* Maximum defined SD card AU size. */
    369392        d->d_sectorsize = mmc_get_sector_size(dev);
     393        d->d_maxsize = mmc_get_max_data(dev) * d->d_sectorsize;
    370394        d->d_mediasize = (off_t)mmc_get_media_size(dev) * d->d_sectorsize;
    371         d->d_stripeoffset = 0;
    372395        d->d_stripesize = mmc_get_erase_sector(dev) * d->d_sectorsize;
    373396        d->d_unit = device_get_unit(dev);
    374397        d->d_flags = DISKFLAG_CANDELETE;
     398        d->d_delmaxsize = mmc_get_erase_sector(dev) * d->d_sectorsize;
     399#endif /* __rtems__ */
     400        strlcpy(d->d_ident, mmc_get_card_sn_string(dev), sizeof(d->d_ident));
     401        strlcpy(d->d_descr, mmc_get_card_id_string(dev), sizeof(d->d_descr));
     402
     403#ifndef __rtems__
    375404        /*
    376          * Display in most natural units.  There's no cards < 1MB.
    377          * The SD standard goes to 2GiB, but the data format supports
    378          * up to 4GiB and some card makers push it up to this limit.
    379          * The SDHC standard only goes to 32GiB (the data format in
    380          * SDHC is good to 2TiB however, which isn't too ugly at
    381          * 2048GiBm, so we note it in passing here and don't add the
    382          * code to print TiB).
     405         * Display in most natural units.  There's no cards < 1MB.  The SD
     406         * standard goes to 2GiB due to its reliance on FAT, but the data
     407         * format supports up to 4GiB and some card makers push it up to this
     408         * limit.  The SDHC standard only goes to 32GiB due to FAT32, but the
     409         * data format supports up to 2TiB however. 2048GB isn't too ugly, so
     410         * we note it in passing here and don't add the code to print
     411         * TB). Since these cards are sold in terms of MB and GB not MiB and
     412         * GiB, report them like that. We also round to the nearest unit, since
     413         * many cards are a few percent short, even of the power of 10 size.
    383414         */
    384         mb = d->d_mediasize >> 20;      /* 1MiB == 1 << 20 */
     415        mb = (d->d_mediasize + 1000000 / 2 - 1) / 1000000;
    385416#else /* __rtems__ */
    386417        mb = mmc_get_media_size(dev);
    387418        mb *= mmc_get_sector_size(dev);
    388         mb >>= 20;
     419        mb = (mb + 1000000 / 2 - 1) / 1000000;
    389420#endif /* __rtems__ */
    390421        unit = 'M';
    391         if (mb >= 10240) {              /* 1GiB = 1024 MiB */
     422        if (mb >= 1000) {
    392423                unit = 'G';
    393                 mb /= 1024;
     424                mb = (mb + 1000 / 2 - 1) / 1000;
    394425        }
    395426        /*
    396427         * Report the clock speed of the underlying hardware, which might be
    397428         * different than what the card reports due to hardware limitations.
    398          * Report how many blocks the hardware transfers at once, but clip the
    399          * number to MAXPHYS since the system won't initiate larger transfers.
     429         * Report how many blocks the hardware transfers at once.
    400430         */
    401431        speed = mmcbr_get_clock(device_get_parent(dev));
    402432        maxblocks = mmc_get_max_data(dev);
    403         if (maxblocks > MAXPHYS)
    404                 maxblocks = MAXPHYS;
    405433        device_printf(dev, "%ju%cB <%s>%s at %s %d.%01dMHz/%dbit/%d-block\n",
    406             mb, unit, mmc_get_card_id_string(dev),
     434            mb, unit, d->d_descr,
    407435            mmc_get_read_only(dev) ? " (read-only)" : "",
    408436            device_get_nameunit(device_get_parent(dev)),
     
    416444        sc->suspend = 0;
    417445        sc->eblock = sc->eend = 0;
    418         kproc_create(&mmcsd_task, sc, &sc->p, 0, 0, "task: mmc/sd card");
     446        kproc_create(&mmcsd_task, sc, &sc->p, 0, 0, "%s: mmc/sd card",
     447            device_get_nameunit(dev));
    419448#else /* __rtems__ */
    420449        rtems_status_code status_code = rtems_media_server_disk_attach(
     
    494523                sc->running = 1;
    495524                MMCSD_UNLOCK(sc);
    496                 kproc_create(&mmcsd_task, sc, &sc->p, 0, 0, "task: mmc/sd card");
     525                kproc_create(&mmcsd_task, sc, &sc->p, 0, 0, "%s: mmc/sd card",
     526                    device_get_nameunit(dev));
    497527        } else
    498528                MMCSD_UNLOCK(sc);
     
    535565}
    536566
     567static const char *
     568mmcsd_errmsg(int e)
     569{
     570        if (e < 0 || e > MMC_ERR_MAX)
     571                return "Bad error code";
     572        return errmsg[e];
     573}
     574
    537575static daddr_t
    538576mmcsd_rw(struct mmcsd_softc *sc, struct bio *bp)
     
    545583        device_t dev = sc->dev;
    546584        int sz = sc->disk->d_sectorsize;
     585        device_t mmcbr = device_get_parent(dev);
    547586
    548587        block = bp->bio_pblkno;
     
    555594                memset(&cmd, 0, sizeof(cmd));
    556595                memset(&stop, 0, sizeof(stop));
     596                memset(&data, 0, sizeof(data));
     597                cmd.mrq = &req;
    557598                req.cmd = &cmd;
    558599                cmd.data = &data;
     
    584625                        stop.arg = 0;
    585626                        stop.flags = MMC_RSP_R1B | MMC_CMD_AC;
     627                        stop.mrq = &req;
    586628                        req.stop = &stop;
    587629                }
    588 //              printf("Len %d  %lld-%lld flags %#x sz %d\n",
    589 //                  (int)data.len, (long long)block, (long long)end, data.flags, sz);
    590                 MMCBUS_WAIT_FOR_REQUEST(device_get_parent(dev), dev,
    591                     &req);
    592                 if (req.cmd->error != MMC_ERR_NONE)
     630                MMCBUS_WAIT_FOR_REQUEST(mmcbr, dev, &req);
     631                if (req.cmd->error != MMC_ERR_NONE) {
     632                        if (ppsratecheck(&sc->log_time, &sc->log_count, LOG_PPS)) {
     633                                device_printf(dev, "Error indicated: %d %s\n",
     634                                    req.cmd->error, mmcsd_errmsg(req.cmd->error));
     635                        }
    593636                        break;
     637                }
    594638                block += numblocks;
    595639        }
     
    606650        int sz = sc->disk->d_sectorsize;
    607651        int erase_sector;
     652        device_t mmcbr = device_get_parent(dev);
    608653
    609654        block = bp->bio_pblkno;
     
    630675        memset(&req, 0, sizeof(req));
    631676        memset(&cmd, 0, sizeof(cmd));
     677        cmd.mrq = &req;
    632678        req.cmd = &cmd;
    633679        if (mmc_get_card_type(dev) == mode_sd)
     
    639685                cmd.arg <<= 9;
    640686        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
    641         MMCBUS_WAIT_FOR_REQUEST(device_get_parent(dev), dev,
    642             &req);
     687        MMCBUS_WAIT_FOR_REQUEST(mmcbr, dev, &req);
    643688        if (req.cmd->error != MMC_ERR_NONE) {
    644689            printf("erase err1: %d\n", req.cmd->error);
     
    658703        cmd.arg--;
    659704        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
    660         MMCBUS_WAIT_FOR_REQUEST(device_get_parent(dev), dev,
    661             &req);
     705        MMCBUS_WAIT_FOR_REQUEST(mmcbr, dev, &req);
    662706        if (req.cmd->error != MMC_ERR_NONE) {
    663707            printf("erase err2: %d\n", req.cmd->error);
     
    671715        cmd.arg = 0;
    672716        cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
    673         MMCBUS_WAIT_FOR_REQUEST(device_get_parent(dev), dev,
    674             &req);
     717        MMCBUS_WAIT_FOR_REQUEST(mmcbr, dev, &req);
    675718        if (req.cmd->error != MMC_ERR_NONE) {
    676719            printf("erase err3 %d\n", req.cmd->error);
     
    697740        struct bio bp;
    698741        daddr_t block, end;
     742        device_t mmcbr = device_get_parent(dev);
    699743
    700744        /* length zero is special and really means flush buffers to media */
     
    702746                return (0);
    703747
    704         bzero(&bp, sizeof(struct bio));
     748        g_reset_bio(&bp);
    705749        bp.bio_disk = disk;
    706750        bp.bio_pblkno = offset / disk->d_sectorsize;
     
    709753        bp.bio_cmd = BIO_WRITE;
    710754        end = bp.bio_pblkno + bp.bio_bcount / sc->disk->d_sectorsize;
    711         MMCBUS_ACQUIRE_BUS(device_get_parent(dev), dev);
     755        MMCBUS_ACQUIRE_BUS(mmcbr, dev);
    712756        block = mmcsd_rw(sc, &bp);
    713         MMCBUS_RELEASE_BUS(device_get_parent(dev), dev);
     757        MMCBUS_RELEASE_BUS(mmcbr, dev);
    714758        return ((end < block) ? EIO : 0);
    715759}
     
    722766        int sz;
    723767        daddr_t block, end;
    724         device_t dev;
    725 
    726         dev = sc->dev;
     768        device_t dev = sc->dev;
     769        device_t mmcbr = device_get_parent(sc->dev);
     770
    727771        while (1) {
    728772                MMCSD_LOCK(sc);
     
    742786                        continue;
    743787                }
    744                 MMCBUS_ACQUIRE_BUS(device_get_parent(dev), dev);
     788                MMCBUS_ACQUIRE_BUS(mmcbr, dev);
    745789                sz = sc->disk->d_sectorsize;
    746790                block = bp->bio_pblkno;
     
    754798                        block = mmcsd_delete(sc, bp);
    755799                }
    756                 MMCBUS_RELEASE_BUS(device_get_parent(dev), dev);
     800                MMCBUS_RELEASE_BUS(mmcbr, dev);
    757801                if (block < end) {
    758802                        bp->bio_error = EIO;
  • freebsd/sys/dev/mmc/mmcvar.h

    ra971614 r0c24e06  
    7070    MMC_IVAR_ERASE_SECTOR,
    7171    MMC_IVAR_MAX_DATA,
    72     MMC_IVAR_CARD_ID_STRING
     72    MMC_IVAR_CARD_ID_STRING,
     73    MMC_IVAR_CARD_SN_STRING,
    7374};
    7475
    7576/*
    76  * Simplified accessors for pci devices
     77 * Simplified accessors for mmc devices
    7778 */
    7879#define MMC_ACCESSOR(var, ivar, type)                                   \
     
    8081
    8182MMC_ACCESSOR(dsr_imp, DSR_IMP, int)
    82 #ifndef __rtems__
    83 MMC_ACCESSOR(media_size, MEDIA_SIZE, off_t)
    84 #else /* __rtems__ */
    85 /*
    86  * The instance variable value storage is limited by the uintptr_t type.  Since
    87  * off_t has more bits than uintptr_t on most RTEMS targets, we need this hack.
    88  */
    89 MMC_ACCESSOR(media_size, MEDIA_SIZE, uintptr_t)
    90 #endif /* __rtems__ */
     83MMC_ACCESSOR(media_size, MEDIA_SIZE, long)
    9184MMC_ACCESSOR(rca, RCA, int)
    9285MMC_ACCESSOR(sector_size, SECTOR_SIZE, int)
     
    9992MMC_ACCESSOR(max_data, MAX_DATA, int)
    10093MMC_ACCESSOR(card_id_string, CARD_ID_STRING, const char *)
     94MMC_ACCESSOR(card_sn_string, CARD_SN_STRING, const char *)
    10195
    10296#endif /* DEV_MMC_MMCVAR_H */
  • libbsd.txt

    ra971614 r0c24e06  
    767767
    768768. sys/dev/dwc/*, trunk, 2015-03-26, cfc3df2b8f708ce8494d9d556e3472a5c8c21b8a
     769. sys/dev/mmc/*, trunk, 2016-08-23, 9fe7c416e6abb28b1398fd3e5687099846800cfd
    769770. sys/dev/usb/*, trunk, 2015-10-30, 968dafb4fcf133cb8beb6fa3c558fecd7dc00ef0
    770771. *, stable/9, 2015-04-08, 99a648a912e81e29d9c4c159cbbe263462f2d719
Note: See TracChangeset for help on using the changeset viewer.