1915 lines · 44.9 KB · C
RawDownload
// SPDX-License-Identifier: GPL-2.0-only/* *  linux/drivers/mmc/core/sd.c * *  Copyright (C) 2003-2004 Russell King, All Rights Reserved. *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved. *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved. */ #include <linux/err.h>#include <linux/sizes.h>#include <linux/slab.h>#include <linux/stat.h>#include <linux/string.h>#include <linux/pm_runtime.h>#include <linux/random.h>#include <linux/scatterlist.h>#include <linux/sysfs.h> #include <linux/mmc/host.h>#include <linux/mmc/card.h>#include <linux/mmc/mmc.h>#include <linux/mmc/sd.h> #include "core.h"#include "card.h"#include "host.h"#include "bus.h"#include "mmc_ops.h"#include "quirks.h"#include "sd.h"#include "sd_ops.h" static const unsigned int tran_exp[] = {	10000,		100000,		1000000,	10000000,	0,		0,		0,		0}; static const unsigned char tran_mant[] = {	0,	10,	12,	13,	15,	20,	25,	30,	35,	40,	45,	50,	55,	60,	70,	80,}; static const unsigned int taac_exp[] = {	1,	10,	100,	1000,	10000,	100000,	1000000, 10000000,}; static const unsigned int taac_mant[] = {	0,	10,	12,	13,	15,	20,	25,	30,	35,	40,	45,	50,	55,	60,	70,	80,}; static const unsigned int sd_au_size[] = {	0,		SZ_16K / 512,		SZ_32K / 512,	SZ_64K / 512,	SZ_128K / 512,	SZ_256K / 512,		SZ_512K / 512,	SZ_1M / 512,	SZ_2M / 512,	SZ_4M / 512,		SZ_8M / 512,	(SZ_8M + SZ_4M) / 512,	SZ_16M / 512,	(SZ_16M + SZ_8M) / 512,	SZ_32M / 512,	SZ_64M / 512,}; #define SD_POWEROFF_NOTIFY_TIMEOUT_MS 1000#define SD_WRITE_EXTR_SINGLE_TIMEOUT_MS 1000 struct sd_busy_data {	struct mmc_card *card;	u8 *reg_buf;}; /* * Given the decoded CSD structure, decode the raw CID to our CID structure. */void mmc_decode_cid(struct mmc_card *card){	u32 *resp = card->raw_cid; 	/*	 * Add the raw card ID (cid) data to the entropy pool. It doesn't	 * matter that not all of it is unique, it's just bonus entropy.	 */	add_device_randomness(&card->raw_cid, sizeof(card->raw_cid)); 	/*	 * SD doesn't currently have a version field so we will	 * have to assume we can parse this.	 */	card->cid.manfid		= unstuff_bits(resp, 120, 8);	card->cid.oemid			= unstuff_bits(resp, 104, 16);	card->cid.prod_name[0]		= unstuff_bits(resp, 96, 8);	card->cid.prod_name[1]		= unstuff_bits(resp, 88, 8);	card->cid.prod_name[2]		= unstuff_bits(resp, 80, 8);	card->cid.prod_name[3]		= unstuff_bits(resp, 72, 8);	card->cid.prod_name[4]		= unstuff_bits(resp, 64, 8);	card->cid.hwrev			= unstuff_bits(resp, 60, 4);	card->cid.fwrev			= unstuff_bits(resp, 56, 4);	card->cid.serial		= unstuff_bits(resp, 24, 32);	card->cid.year			= unstuff_bits(resp, 12, 8);	card->cid.month			= unstuff_bits(resp, 8, 4); 	card->cid.year += 2000; /* SD cards year offset */ 	/* some product names may include trailing whitespace */	strim(card->cid.prod_name);} /* * Given a 128-bit response, decode to our card CSD structure. */static int mmc_decode_csd(struct mmc_card *card, bool is_sduc){	struct mmc_csd *csd = &card->csd;	unsigned int e, m, csd_struct;	u32 *resp = card->raw_csd; 	csd_struct = unstuff_bits(resp, 126, 2); 	switch (csd_struct) {	case 0:		m = unstuff_bits(resp, 115, 4);		e = unstuff_bits(resp, 112, 3);		csd->taac_ns	 = (taac_exp[e] * taac_mant[m] + 9) / 10;		csd->taac_clks	 = unstuff_bits(resp, 104, 8) * 100; 		m = unstuff_bits(resp, 99, 4);		e = unstuff_bits(resp, 96, 3);		csd->max_dtr	  = tran_exp[e] * tran_mant[m];		csd->cmdclass	  = unstuff_bits(resp, 84, 12); 		e = unstuff_bits(resp, 47, 3);		m = unstuff_bits(resp, 62, 12);		csd->capacity	  = (1 + m) << (e + 2); 		csd->read_blkbits = unstuff_bits(resp, 80, 4);		csd->read_partial = unstuff_bits(resp, 79, 1);		csd->write_misalign = unstuff_bits(resp, 78, 1);		csd->read_misalign = unstuff_bits(resp, 77, 1);		csd->dsr_imp = unstuff_bits(resp, 76, 1);		csd->r2w_factor = unstuff_bits(resp, 26, 3);		csd->write_blkbits = unstuff_bits(resp, 22, 4);		csd->write_partial = unstuff_bits(resp, 21, 1); 		if (unstuff_bits(resp, 46, 1)) {			csd->erase_size = 1;		} else if (csd->write_blkbits >= 9) {			csd->erase_size = unstuff_bits(resp, 39, 7) + 1;			csd->erase_size <<= csd->write_blkbits - 9;		} 		if (unstuff_bits(resp, 13, 1))			mmc_card_set_readonly(card);		break;	case 1:	case 2:		/*		 * This is a block-addressed SDHC, SDXC or SDUC card.		 * Most interesting fields are unused and have fixed		 * values. To avoid getting tripped by buggy cards,		 * we assume those fixed values ourselves.		 */		mmc_card_set_blockaddr(card); 		csd->taac_ns	 = 0; /* Unused */		csd->taac_clks	 = 0; /* Unused */ 		m = unstuff_bits(resp, 99, 4);		e = unstuff_bits(resp, 96, 3);		csd->max_dtr	  = tran_exp[e] * tran_mant[m];		csd->cmdclass	  = unstuff_bits(resp, 84, 12); 		if (csd_struct == 1)			m = unstuff_bits(resp, 48, 22);		else			m = unstuff_bits(resp, 48, 28);		csd->c_size = m; 		if (csd->c_size >= 0x400000 && is_sduc)			mmc_card_set_ult_capacity(card);		else if (csd->c_size >= 0xFFFF)			mmc_card_set_ext_capacity(card); 		csd->capacity     = (1 + (typeof(sector_t))m) << 10; 		csd->read_blkbits = 9;		csd->read_partial = 0;		csd->write_misalign = 0;		csd->read_misalign = 0;		csd->r2w_factor = 4; /* Unused */		csd->write_blkbits = 9;		csd->write_partial = 0;		csd->erase_size = 1; 		if (unstuff_bits(resp, 13, 1))			mmc_card_set_readonly(card);		break;	default:		pr_err("%s: unrecognised CSD structure version %d\n",			mmc_hostname(card->host), csd_struct);		return -EINVAL;	} 	card->erase_size = csd->erase_size; 	return 0;} /* * Given a 64-bit response, decode to our card SCR structure. */int mmc_decode_scr(struct mmc_card *card){	struct sd_scr *scr = &card->scr;	unsigned int scr_struct;	u32 resp[4]; 	resp[3] = card->raw_scr[1];	resp[2] = card->raw_scr[0]; 	scr_struct = unstuff_bits(resp, 60, 4);	if (scr_struct != 0) {		pr_err("%s: unrecognised SCR structure version %d\n",			mmc_hostname(card->host), scr_struct);		return -EINVAL;	} 	scr->sda_vsn = unstuff_bits(resp, 56, 4);	scr->bus_widths = unstuff_bits(resp, 48, 4);	if (scr->sda_vsn == SCR_SPEC_VER_2)		/* Check if Physical Layer Spec v3.0 is supported */		scr->sda_spec3 = unstuff_bits(resp, 47, 1); 	if (scr->sda_spec3) {		scr->sda_spec4 = unstuff_bits(resp, 42, 1);		scr->sda_specx = unstuff_bits(resp, 38, 4);	} 	if (unstuff_bits(resp, 55, 1))		card->erased_byte = 0xFF;	else		card->erased_byte = 0x0; 	if (scr->sda_spec4)		scr->cmds = unstuff_bits(resp, 32, 4);	else if (scr->sda_spec3)		scr->cmds = unstuff_bits(resp, 32, 2); 	/* SD Spec says: any SD Card shall set at least bits 0 and 2 */	if (!(scr->bus_widths & SD_SCR_BUS_WIDTH_1) ||	    !(scr->bus_widths & SD_SCR_BUS_WIDTH_4)) {		pr_err("%s: invalid bus width\n", mmc_hostname(card->host));		return -EINVAL;	} 	return 0;} /* * Fetch and process SD Status register. */static int mmc_read_ssr(struct mmc_card *card){	unsigned int au, es, et, eo;	__be32 *raw_ssr;	u32 resp[4] = {};	u8 discard_support;	int i; 	if (!(card->csd.cmdclass & CCC_APP_SPEC)) {		pr_warn("%s: card lacks mandatory SD Status function\n",			mmc_hostname(card->host));		return 0;	} 	raw_ssr = kmalloc(sizeof(card->raw_ssr), GFP_KERNEL);	if (!raw_ssr)		return -ENOMEM; 	if (mmc_app_sd_status(card, raw_ssr)) {		pr_warn("%s: problem reading SD Status register\n",			mmc_hostname(card->host));		kfree(raw_ssr);		return 0;	} 	for (i = 0; i < 16; i++)		card->raw_ssr[i] = be32_to_cpu(raw_ssr[i]); 	kfree(raw_ssr); 	/*	 * unstuff_bits only works with four u32s so we have to offset the	 * bitfield positions accordingly.	 */	au = unstuff_bits(card->raw_ssr, 428 - 384, 4);	if (au) {		if (au <= 9 || card->scr.sda_spec3) {			card->ssr.au = sd_au_size[au];			es = unstuff_bits(card->raw_ssr, 408 - 384, 16);			et = unstuff_bits(card->raw_ssr, 402 - 384, 6);			if (es && et) {				eo = unstuff_bits(card->raw_ssr, 400 - 384, 2);				card->ssr.erase_timeout = (et * 1000) / es;				card->ssr.erase_offset = eo * 1000;			}		} else {			pr_warn("%s: SD Status: Invalid Allocation Unit size\n",				mmc_hostname(card->host));		}	} 	/*	 * starting SD5.1 discard is supported if DISCARD_SUPPORT (b313) is set	 */	resp[3] = card->raw_ssr[6];	discard_support = unstuff_bits(resp, 313 - 288, 1);	card->erase_arg = (card->scr.sda_specx && discard_support) ?			    SD_DISCARD_ARG : SD_ERASE_ARG; 	return 0;} /* * Fetches and decodes switch information */static int mmc_read_switch(struct mmc_card *card){	int err;	u8 *status; 	if (card->scr.sda_vsn < SCR_SPEC_VER_1)		return 0; 	if (!(card->csd.cmdclass & CCC_SWITCH)) {		pr_warn("%s: card lacks mandatory switch function, performance might suffer\n",			mmc_hostname(card->host));		return 0;	} 	status = kmalloc(64, GFP_KERNEL);	if (!status)		return -ENOMEM; 	/*	 * Find out the card's support bits with a mode 0 operation.	 * The argument does not matter, as the support bits do not	 * change with the arguments.	 */	err = mmc_sd_switch(card, SD_SWITCH_CHECK, 0, 0, status);	if (err) {		/*		 * If the host or the card can't do the switch,		 * fail more gracefully.		 */		if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)			goto out; 		pr_warn("%s: problem reading Bus Speed modes\n",			mmc_hostname(card->host));		err = 0; 		goto out;	} 	if (status[13] & SD_MODE_HIGH_SPEED)		card->sw_caps.hs_max_dtr = card->host->max_sd_hs_hz ?: HIGH_SPEED_MAX_DTR; 	if (card->scr.sda_spec3) {		card->sw_caps.sd3_bus_mode = status[13];		/* Driver Strengths supported by the card */		card->sw_caps.sd3_drv_type = status[9];		card->sw_caps.sd3_curr_limit = status[7] | status[6] << 8;	} out:	kfree(status); 	return err;} /* * Test if the card supports high-speed mode and, if so, switch to it. */int mmc_sd_switch_hs(struct mmc_card *card){	int err;	u8 *status; 	if (card->scr.sda_vsn < SCR_SPEC_VER_1)		return 0; 	if (!(card->csd.cmdclass & CCC_SWITCH))		return 0; 	if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))		return 0; 	if (card->sw_caps.hs_max_dtr == 0)		return 0; 	status = kmalloc(64, GFP_KERNEL);	if (!status)		return -ENOMEM; 	err = mmc_sd_switch(card, SD_SWITCH_SET, 0,			HIGH_SPEED_BUS_SPEED, status);	if (err)		goto out; 	if ((status[16] & 0xF) != HIGH_SPEED_BUS_SPEED) {		pr_warn("%s: Problem switching card into high-speed mode!\n",			mmc_hostname(card->host));		err = 0;	} else {		err = 1;	} out:	kfree(status); 	return err;} static int sd_select_driver_type(struct mmc_card *card, u8 *status){	int card_drv_type, drive_strength, drv_type;	int err; 	card->drive_strength = 0; 	card_drv_type = card->sw_caps.sd3_drv_type | SD_DRIVER_TYPE_B; 	drive_strength = mmc_select_drive_strength(card,						   card->sw_caps.uhs_max_dtr,						   card_drv_type, &drv_type); 	if (drive_strength) {		err = mmc_sd_switch(card, SD_SWITCH_SET, 2,				drive_strength, status);		if (err)			return err;		if ((status[15] & 0xF) != drive_strength) {			pr_warn("%s: Problem setting drive strength!\n",				mmc_hostname(card->host));			return 0;		}		card->drive_strength = drive_strength;	} 	if (drv_type)		mmc_set_driver_type(card->host, drv_type); 	return 0;} static void sd_update_bus_speed_mode(struct mmc_card *card){	/*	 * If the host doesn't support any of the UHS-I modes, fallback on	 * default speed.	 */	if (!mmc_host_can_uhs(card->host)) {		card->sd_bus_speed = 0;		return;	} 	if ((card->host->caps & MMC_CAP_UHS_SDR104) &&	    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {			card->sd_bus_speed = UHS_SDR104_BUS_SPEED;	} else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {			card->sd_bus_speed = UHS_DDR50_BUS_SPEED;	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |		    MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &		    SD_MODE_UHS_SDR50)) {			card->sd_bus_speed = UHS_SDR50_BUS_SPEED;	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&		   (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {			card->sd_bus_speed = UHS_SDR25_BUS_SPEED;	} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |		    MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |		    MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &		    SD_MODE_UHS_SDR12)) {			card->sd_bus_speed = UHS_SDR12_BUS_SPEED;	}} static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status){	int err;	unsigned int timing = 0; 	switch (card->sd_bus_speed) {	case UHS_SDR104_BUS_SPEED:		timing = MMC_TIMING_UHS_SDR104;		card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;		break;	case UHS_DDR50_BUS_SPEED:		timing = MMC_TIMING_UHS_DDR50;		card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;		break;	case UHS_SDR50_BUS_SPEED:		timing = MMC_TIMING_UHS_SDR50;

Lines 1–500 of 1915.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t