From patchwork Sun May 22 00:40:42 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Mok, Tze Siong" X-Patchwork-Id: 806192 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by demeter2.kernel.org (8.14.4/8.14.3) with ESMTP id p4M0er85010789 for ; Sun, 22 May 2011 00:40:53 GMT Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751073Ab1EVAkw (ORCPT ); Sat, 21 May 2011 20:40:52 -0400 Received: from mga03.intel.com ([143.182.124.21]:36891 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750973Ab1EVAkw convert rfc822-to-8bit (ORCPT ); Sat, 21 May 2011 20:40:52 -0400 Received: from azsmga001.ch.intel.com ([10.2.17.19]) by azsmga101.ch.intel.com with ESMTP; 21 May 2011 17:40:51 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="4.65,249,1304319600"; d="scan'208";a="440516288" Received: from pgsmsx602.gar.corp.intel.com ([10.221.43.81]) by azsmga001.ch.intel.com with ESMTP; 21 May 2011 17:40:50 -0700 Received: from pgsmsx505.gar.corp.intel.com ([10.221.43.83]) by pgsmsx602.gar.corp.intel.com ([10.221.43.81]) with mapi; Sun, 22 May 2011 08:40:44 +0800 From: "Mok, Tze Siong" To: Philip Rakity , Chris Ball CC: Tomoya MORINAGA , Takashi Iwai , Mark Brown , "linux-mmc@vger.kernel.org" Date: Sun, 22 May 2011 08:40:42 +0800 Subject: RE: [PATCH] mmc: eMMC bus width may not work on all platforms Thread-Topic: [PATCH] mmc: eMMC bus width may not work on all platforms Thread-Index: AcwUwe4JhuDAYWIESWCXryRfQyCcogDVWCjg Message-ID: <1482D9D127C1754E8684047CF53F7660622B177DBE@pgsmsx505.gar.corp.intel.com> References: <2FBABAF6-BFF6-46C9-BE6C-D4CA1EE9BD03@marvell.com> In-Reply-To: <2FBABAF6-BFF6-46C9-BE6C-D4CA1EE9BD03@marvell.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: acceptlanguage: en-US MIME-Version: 1.0 Sender: linux-mmc-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-mmc@vger.kernel.org X-Greylist: IP, sender and recipient auto-whitelisted, not delayed by milter-greylist-4.2.6 (demeter2.kernel.org [140.211.167.43]); Sun, 22 May 2011 00:40:54 +0000 (UTC) Hi Chris, The following patch https://patchwork.kernel.org/patch/792162/ is tested using Intel EG20T PCH, the Transcend MMC 1bit card can now be detected, read and write to the card successfully. Note : Need to add MMC_CAP_BUS_WIDTH_TEST caps into the SD host controller HW platform code in order to work. Tested-by: tze.siong.mok@intel.com -----Original Message----- From: Philip Rakity [mailto:prakity@marvell.com] Sent: Wednesday, May 18, 2011 2:41 AM To: linux-mmc@vger.kernel.org Cc: Chris Ball; Mok, Tze Siong; Tomoya MORINAGA; Takashi Iwai; Mark Brown Subject: [PATCH] mmc: eMMC bus width may not work on all platforms CMD19 -- The offical way to validate bus widths from the JEDEC spec does not work on all platforms. Some platforms that use PCI/PCIe to connect their SD controllers are known to fail. If the quirk MMC_BUS_WIDTH_TEST is not defined we try to figure out the bus width by reading the ext_csd at different bus widths and compare this against the ext_csd read in 1 bit mode. If no ext_csd is available we default to 1 bit operations. Code has been tested on mmp2 against 8 bit eMMC and Transcend 2GB card that is known to not work in 4 bit mode. The physical pins on the card are not present to support 4 bit operation. Signed-off-by: Philip Rakity --- drivers/mmc/core/mmc.c | 135 ++++++++++++++++++++++++++++++++++++++++++++---- 1 files changed, 125 insertions(+), 10 deletions(-) diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c index baab027..42b5045 100644 --- a/drivers/mmc/core/mmc.c +++ b/drivers/mmc/core/mmc.c @@ -174,14 +174,17 @@ static int mmc_decode_csd(struct mmc_card *card) } /* - * Read and decode extended CSD. + * Read extended CSD. */ -static int mmc_read_ext_csd(struct mmc_card *card) +static int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd) { int err; u8 *ext_csd; BUG_ON(!card); + BUG_ON(!new_ext_csd); + + *new_ext_csd = NULL; if (card->csd.mmca_vsn < CSD_SPEC_VER_4) return 0; @@ -199,12 +202,15 @@ static int mmc_read_ext_csd(struct mmc_card *card) err = mmc_send_ext_csd(card, ext_csd); if (err) { + kfree(ext_csd); + *new_ext_csd = NULL; + /* If the host or the card can't do the switch, * fail more gracefully. */ if ((err != -EINVAL) && (err != -ENOSYS) && (err != -EFAULT)) - goto out; + return err; /* * High capacity cards should have this "magic" size @@ -222,9 +228,23 @@ static int mmc_read_ext_csd(struct mmc_card *card) mmc_hostname(card->host)); err = 0; } + } else + *new_ext_csd = ext_csd; - goto out; - } + return err; +} + +/* + * Decode extended CSD. + */ +static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd) +{ + int err = 0; + + BUG_ON(!card); + + if (!ext_csd) + return 0; /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */ if (card->csd.structure == 3) { @@ -372,8 +392,92 @@ static int mmc_read_ext_csd(struct mmc_card *card) card->erased_byte = 0x0; out: + return err; +} + +static inline void mmc_free_ext_csd(u8 *ext_csd) +{ kfree(ext_csd); +} + +static int mmc_cmp_ext_csd(u8 *ext_csd, u8 *bw_ext_csd, unsigned bus_width) +{ + if (ext_csd == NULL || bw_ext_csd == NULL) + return bus_width != MMC_BUS_WIDTH_1; + + if (bus_width == MMC_BUS_WIDTH_1) + return 0; + + /* only compare read only fields */ + if (ext_csd[EXT_CSD_PARTITION_SUPPORT] != + bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) + return -1; + + if (ext_csd[EXT_CSD_ERASED_MEM_CONT] != + bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) + return -2; + + if (ext_csd[EXT_CSD_REV] != + bw_ext_csd[EXT_CSD_REV]) + return -3; + + if (ext_csd[EXT_CSD_STRUCTURE] != + bw_ext_csd[EXT_CSD_STRUCTURE]) + return -4; + + if (ext_csd[EXT_CSD_CARD_TYPE] != + bw_ext_csd[EXT_CSD_CARD_TYPE]) + return -5; + + if (ext_csd[EXT_CSD_S_A_TIMEOUT] != + bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) + return -6; + + if (ext_csd[EXT_CSD_HC_WP_GRP_SIZE] != + bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) + return -7; + + if (ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT] != + bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) + return -8; + + if (ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] != + bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) + return -9; + + if (ext_csd[EXT_CSD_SEC_TRIM_MULT] != + bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) + return -10; + + if (ext_csd[EXT_CSD_SEC_ERASE_MULT] != + bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) + return -11; + + if (ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT] != + bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) + return -12; + + if (ext_csd[EXT_CSD_TRIM_MULT] != + bw_ext_csd[EXT_CSD_TRIM_MULT]) + return -13; + + return memcmp(&ext_csd[EXT_CSD_SEC_CNT], + &bw_ext_csd[EXT_CSD_SEC_CNT], + 4); +} + +static int mmc_compare_ext_csds(struct mmc_card *card, u8 *ext_csd, + unsigned bus_width) +{ + u8 *bw_ext_csd; + int err; + + err = mmc_get_ext_csd(card, &bw_ext_csd); + if (!err) + err = mmc_cmp_ext_csd(ext_csd, bw_ext_csd, bus_width); + + mmc_free_ext_csd(bw_ext_csd); return err; } @@ -438,6 +542,7 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr, u32 cid[4]; unsigned int max_dtr; u32 rocr; + u8 *ext_csd = NULL; BUG_ON(!host); WARN_ON(!host->claimed); @@ -536,7 +641,11 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr, /* * Fetch and process extended CSD. */ - err = mmc_read_ext_csd(card); + + err = mmc_get_ext_csd(card, &ext_csd); + if (err) + goto free_card; + err = mmc_read_ext_csd(card, ext_csd); if (err) goto free_card; @@ -676,14 +785,18 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr, 0); if (!err) { mmc_set_bus_width(card->host, bus_width); + /* * If controller can't handle bus width test, - * use the highest bus width to maintain - * compatibility with previous MMC behavior. + * compare ext_csd previously read in 1 bit mode + * against ext_csd at new bus width */ if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST)) - break; - err = mmc_bus_test(card, bus_width); + err = mmc_compare_ext_csds(card, + ext_csd, + bus_width); + else + err = mmc_bus_test(card, bus_width); if (!err) break; } @@ -730,12 +843,14 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr, if (!oldcard) host->card = card; + mmc_free_ext_csd(ext_csd); return 0; free_card: if (!oldcard) mmc_remove_card(card); err: + mmc_free_ext_csd(ext_csd); return err; }