From nobody Sat Nov 30 02:56:52 2024 Received: from mail-pl1-f181.google.com (mail-pl1-f181.google.com [209.85.214.181]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AF0A31D86D6; Fri, 13 Sep 2024 10:29:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.181 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1726223357; cv=none; b=IODFkMIUyMi//tb5qJDMR/SdU/4bGbyvGRs4mnjlFUmdDq0O8PfR75TB48v6hz1EzoCghBEXmoJBRxsjcKCcNyr7cxQa8Uk5EJaTlzi4vFiT3dR1yAqiJcVZfedosnLv+bCYe/DCVDoh21BVpZdNEAISFAgugNO7KVjCZlz3kwY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1726223357; c=relaxed/simple; bh=zRef6mPBfqeedyCONpzl8GnqRecxpBK1jPu9OZCN/s8=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=ip1Spu0SiQfbJKKsuWJlzlvrHI0w4sCLA10cXXnvsyFKduSNKjtxex5ITtFpTq6LFSSF0E8T1Xnju6NizAm0+OYDEsjUeGx4XIJ2xw/j/eWOAiSN7ei09Ddl+iIXxjOVfU2bRZxoaLqiZTO56BHIwRzC3oUD2hJQi0fTQQigG2U= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=KqlVfsK/; arc=none smtp.client-ip=209.85.214.181 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="KqlVfsK/" Received: by mail-pl1-f181.google.com with SMTP id d9443c01a7336-2053525bd90so6737205ad.0; Fri, 13 Sep 2024 03:29:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1726223354; x=1726828154; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=/sk+SRT20aUCkisPhWNhj+XRCKkchDvOQveIRHdHuMo=; b=KqlVfsK/wumGorVcOpr2iR0aB09lLGfbFC3ypMXFnH8ImUHvLrXht2zSTmXnIOO9Xo /C/yFK8UJkAzCqn/1A6DYSpDe2M19rLXGTsg8o7PF2UYIiVKyb17nvIr5FQ7HkdBRWPj 26etp1fMwXJYjiDe4c2jpE9Hs5X2XRTKDvImJvlm5RLAAgmnCqULKCNa3gfUJdOVXLNT wPyYLeztkH3xuSaYvitnj8Tet+3nKh/FvPGiFPHOZl6X9/AgEVjlG9C111VcZ9wx2KeW E3zJzowXgUzIJBhoSX01hpHLfS/+jmhx/4GuEossutAbLrkc0PaPgsf3SW8t2iMGxcT+ 2D7g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1726223354; x=1726828154; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=/sk+SRT20aUCkisPhWNhj+XRCKkchDvOQveIRHdHuMo=; b=at23xjOj+AbCkVfXP/suKkTJWrO9MW4A6wcmkzUHUZjq7Jx1tHuXHhAw4YtP2Mc3vg A3K466LyalkvkQeI/XePgpdsUaT4MfaOtNUo9M8R8MjJ69v4xAVn0GxqWNWc7e4nDDMm hlvugbqLZkZTu9XaLAfg+KMm9zJi4SMeY8NWqXQPdqPqW+TmEmXZ9ouIcZAG+VrzgibF ZtcGWPfni/gJsmXyvZ1Mv5dnVmM9VMP/OATJkn4Tc22vb6tgTjCowvIJEQsRZBJ2kyZG 1zkM6PXRXKIzorm2J9/vjssIxnT0zDrEL450EfLtJNtTn11Mi7zrEAoullKWMZziBO0s 1A/g== X-Forwarded-Encrypted: i=1; AJvYcCWtmxZ1hzRT2p3f+hT66BwVN5laC9IHMVXjPBV2n6fE3MTOEvNjadpnGXHtgUEdc2tHE/AVLC3oCrzmXmI=@vger.kernel.org X-Gm-Message-State: AOJu0Yzij6v2++TVPWgBX7rDA6sC9pBtYQe1EE4b60Gk4t9sBMpCOE77 M00s69Uemyg9Z1VDcaXjJkppyy6q173jJCMUkKl+2yVVRJHUOmpc X-Google-Smtp-Source: AGHT+IFRnXauZOoG1C3OuZ1jXMk/AVEVvB/AHTHyNkJNQdJVwvR9f/4kwSrxGND4n9prnk8Iom6BWw== X-Received: by 2002:a17:902:f604:b0:206:64b4:3088 with SMTP id d9443c01a7336-20782434766mr33983325ad.29.1726223353519; Fri, 13 Sep 2024 03:29:13 -0700 (PDT) Received: from localhost.localdomain ([2402:7500:568:acb8:4bcf:ada3:4620:3cfb]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-7db1fad0ac6sm3137683a12.0.2024.09.13.03.29.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Sep 2024 03:29:13 -0700 (PDT) From: Victor Shih To: ulf.hansson@linaro.org, adrian.hunter@intel.com Cc: linux-mmc@vger.kernel.org, linux-kernel@vger.kernel.org, benchuanggli@gmail.com, Lucas.Lai@genesyslogic.com.tw, HL.Liu@genesyslogic.com.tw, Greg.tu@genesyslogic.com.tw, dlunev@chromium.org, Victor Shih , Jason Lai , Victor Shih Subject: [PATCH V22 07/22] mmc: core: Support UHS-II card control and access Date: Fri, 13 Sep 2024 18:28:21 +0800 Message-Id: <20240913102836.6144-8-victorshihgli@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20240913102836.6144-1-victorshihgli@gmail.com> References: <20240913102836.6144-1-victorshihgli@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Victor Shih Embed UHS-II access/control functionality into the MMC request processing flow. Signed-off-by: Ulf Hansson Signed-off-by: Jason Lai Signed-off-by: Victor Shih --- Updates in V16: - Separate the Error Recovery mechanism into a separate patch#8. Updates in V15: - Move struct uhs2_command uhs2_cmd to struct mmc_request and modify whatever other changers to make it work. - Refer the SD Host Controller Standard Specification Section 3.10 to add Error Recovery mechanism to recover the command error. Updates in V13: - Separate __mmc_go_idle() into one patch for re-factorring the code. - Move mmc_decode_scr declaration to sd.h. - Ues uhs2_sd_tran to stead MMC_UHS2_SD_TRAN.=20 - Drop unnecessary comment. Updates in V12: - Use mmc_op_multi() to check DCMD which supports multi read/write in mmc_uhs2_prepare_cmd(). Updates in V10: - Move some definitions of PatchV9[02/23] to PatchV10[06/23]. - Move some definitions of PatchV9[05/23] to PatchV10[06/23]. - Drop do_multi in the mmc_blk_rw_rq_prep(). - Use tmode_half_duplex to instead of uhs2_tmode0_flag. - Move entire control of the tmode into mmc_uhs2_prepare_cmd(). Updates in V8: - Add MMC_UHS2_SUPPORT to be cleared in sd_uhs2_detect(). - Modify return value in sd_uhs2_attach(). Updates in V7: - Add mmc_uhs2_card_prepare_cmd helper function in sd_ops.h. - Drop uhs2_state in favor of ios->timing. - Remove unnecessary functions. --- drivers/mmc/core/core.c | 6 +- drivers/mmc/core/sd.c | 10 +- drivers/mmc/core/sd.h | 5 + drivers/mmc/core/sd_ops.c | 9 + drivers/mmc/core/sd_ops.h | 13 + drivers/mmc/core/sd_uhs2.c | 1100 ++++++++++++++++++++++++++++++++++-- include/linux/mmc/core.h | 17 + include/linux/mmc/host.h | 15 + 8 files changed, 1136 insertions(+), 39 deletions(-) diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c index 8b8aff131f8b..1841a2190571 100644 --- a/drivers/mmc/core/core.c +++ b/drivers/mmc/core/core.c @@ -351,6 +351,8 @@ int mmc_start_request(struct mmc_host *host, struct mmc= _request *mrq) if (err) return err; =20 + mmc_uhs2_card_prepare_cmd(host, mrq); + led_trigger_event(host->led, LED_FULL); __mmc_start_request(host, mrq); =20 @@ -450,6 +452,8 @@ int mmc_cqe_start_req(struct mmc_host *host, struct mmc= _request *mrq) if (err) goto out_err; =20 + mmc_uhs2_card_prepare_cmd(host, mrq); + err =3D host->cqe_ops->cqe_request(host, mrq); if (err) goto out_err; @@ -1132,7 +1136,7 @@ u32 mmc_select_voltage(struct mmc_host *host, u32 ocr) return 0; } =20 - if (host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) { + if (!mmc_card_uhs2(host) && host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) { bit =3D ffs(ocr) - 1; ocr &=3D 3 << bit; mmc_power_cycle(host, ocr); diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c index 12fe282bea77..d5576a2f4435 100644 --- a/drivers/mmc/core/sd.c +++ b/drivers/mmc/core/sd.c @@ -194,7 +194,7 @@ static int mmc_decode_csd(struct mmc_card *card) /* * Given a 64-bit response, decode to our card SCR structure. */ -static int mmc_decode_scr(struct mmc_card *card) +int mmc_decode_scr(struct mmc_card *card) { struct sd_scr *scr =3D &card->scr; unsigned int scr_struct; @@ -894,7 +894,7 @@ int mmc_sd_get_csd(struct mmc_card *card) return 0; } =20 -static int mmc_sd_get_ro(struct mmc_host *host) +int mmc_sd_get_ro(struct mmc_host *host) { int ro; =20 @@ -1623,7 +1623,7 @@ static void mmc_sd_detect(struct mmc_host *host) } } =20 -static int sd_can_poweroff_notify(struct mmc_card *card) +int sd_can_poweroff_notify(struct mmc_card *card) { return card->ext_power.feature_support & SD_EXT_POWER_OFF_NOTIFY; } @@ -1651,7 +1651,7 @@ static int sd_busy_poweroff_notify_cb(void *cb_data, = bool *busy) return 0; } =20 -static int sd_poweroff_notify(struct mmc_card *card) +int sd_poweroff_notify(struct mmc_card *card) { struct sd_busy_data cb_data; u8 *reg_buf; @@ -1699,7 +1699,7 @@ static int _mmc_sd_suspend(struct mmc_host *host) if (mmc_card_suspended(card)) goto out; =20 - if (sd_can_poweroff_notify(card)) + if (mmc_sd_can_poweroff_notify(card)) err =3D sd_poweroff_notify(card); else if (!mmc_host_is_spi(host)) err =3D mmc_deselect_cards(host); diff --git a/drivers/mmc/core/sd.h b/drivers/mmc/core/sd.h index fe6dd46927a4..49afaef269cd 100644 --- a/drivers/mmc/core/sd.h +++ b/drivers/mmc/core/sd.h @@ -11,10 +11,15 @@ struct mmc_card; =20 int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr); int mmc_sd_get_csd(struct mmc_card *card); +int mmc_decode_scr(struct mmc_card *card); +int mmc_sd_get_ro(struct mmc_host *host); void mmc_decode_cid(struct mmc_card *card); int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card, bool reinit); unsigned mmc_sd_get_max_clock(struct mmc_card *card); int mmc_sd_switch_hs(struct mmc_card *card); =20 +int sd_can_poweroff_notify(struct mmc_card *card); +int sd_poweroff_notify(struct mmc_card *card); + #endif diff --git a/drivers/mmc/core/sd_ops.c b/drivers/mmc/core/sd_ops.c index f93c392040ae..5cd1216edf0d 100644 --- a/drivers/mmc/core/sd_ops.c +++ b/drivers/mmc/core/sd_ops.c @@ -41,6 +41,15 @@ int mmc_app_cmd(struct mmc_host *host, struct mmc_card *= card) if (WARN_ON(card && card->host !=3D host)) return -EINVAL; =20 + /* + * UHS2 packet has APP bit so only set APP_CMD flag here. + * Will set the APP bit when assembling UHS2 packet. + */ + if (host->uhs2_sd_tran) { + host->uhs2_app_cmd =3D true; + return 0; + } + cmd.opcode =3D MMC_APP_CMD; =20 if (card) { diff --git a/drivers/mmc/core/sd_ops.h b/drivers/mmc/core/sd_ops.h index 7667fc223b74..e3af68a52de8 100644 --- a/drivers/mmc/core/sd_ops.h +++ b/drivers/mmc/core/sd_ops.h @@ -11,6 +11,7 @@ #include =20 struct mmc_card; +struct mmc_command; struct mmc_host; =20 int mmc_app_set_bus_width(struct mmc_card *card, int width); @@ -21,6 +22,18 @@ int mmc_send_relative_addr(struct mmc_host *host, unsign= ed int *rca); int mmc_app_send_scr(struct mmc_card *card); int mmc_app_sd_status(struct mmc_card *card, void *ssr); int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card); +void mmc_uhs2_prepare_cmd(struct mmc_host *host, struct mmc_request *mrq); + +static inline void mmc_uhs2_card_prepare_cmd(struct mmc_host *host, struct= mmc_request *mrq) +{ + if (host->uhs2_sd_tran) + mmc_uhs2_prepare_cmd(host, mrq); +} + +static inline int mmc_sd_can_poweroff_notify(struct mmc_card *card) +{ + return card->ext_power.feature_support & SD_EXT_POWER_OFF_NOTIFY; +} =20 #endif =20 diff --git a/drivers/mmc/core/sd_uhs2.c b/drivers/mmc/core/sd_uhs2.c index beb2541338ff..85939a2582dc 100644 --- a/drivers/mmc/core/sd_uhs2.c +++ b/drivers/mmc/core/sd_uhs2.c @@ -1,23 +1,51 @@ // SPDX-License-Identifier: GPL-2.0-only /* * Copyright (C) 2021 Linaro Ltd - * * Author: Ulf Hansson * + * Copyright (C) 2014 Intel Corp, All Rights Reserved. + * Author: Yi Sun + * + * Copyright (C) 2020 Genesys Logic, Inc. + * Authors: Ben Chuang + * + * Copyright (C) 2020 Linaro Limited + * Author: AKASHI Takahiro + * + * Copyright (C) 2022 Genesys Logic, Inc. + * Authors: Jason Lai + * + * Copyright (C) 2023 Genesys Logic, Inc. + * Authors: Victor Shih + * * Support for SD UHS-II cards */ #include +#include =20 #include #include +#include +#include +#include =20 +#include "card.h" #include "core.h" #include "bus.h" #include "sd.h" +#include "sd_ops.h" #include "mmc_ops.h" =20 +#define UHS2_WAIT_CFG_COMPLETE_PERIOD_US (1 * 1000) +#define UHS2_WAIT_CFG_COMPLETE_TIMEOUT_MS 100 + static const unsigned int sd_uhs2_freqs[] =3D { 52000000, 26000000 }; =20 +struct sd_uhs2_wait_active_state_data { + struct mmc_host *host; + struct mmc_command *cmd; +}; + static int sd_uhs2_power_up(struct mmc_host *host) { int err; @@ -42,12 +70,46 @@ static int sd_uhs2_power_off(struct mmc_host *host) =20 host->ios.vdd =3D 0; host->ios.clock =3D 0; - host->ios.timing =3D MMC_TIMING_LEGACY; + /* Must set UHS2 timing to identify UHS2 mode */ + host->ios.timing =3D MMC_TIMING_UHS2_SPEED_A; host->ios.power_mode =3D MMC_POWER_OFF; + host->uhs2_sd_tran =3D false; =20 return host->ops->uhs2_control(host, UHS2_SET_IOS); } =20 +/* + * sd_uhs2_cmd_assemble() - build up UHS-II command packet which is embedd= ed in + * mmc_command structure + * @cmd: MMC command to executed + * @uhs2_cmd: UHS2 command corresponded to MMC command + * @header: Header field of UHS-II command cxpacket + * @arg: Argument field of UHS-II command packet + * @payload: Payload field of UHS-II command packet + * @plen: Payload length + * @resp: Response buffer is allocated by caller and it is used to keep + * the response of CM-TRAN command. For SD-TRAN command, uhs2= _resp + * should be null and SD-TRAN command response should be stor= ed in + * resp of mmc_command. + * @resp_len: Response buffer length + * + * The uhs2_command structure contains message packets which are transmite= d/ + * received on UHS-II bus. This function fills in the contents of uhs2_com= mand + * structure and embededs UHS2 command into mmc_command structure, which i= s used + * in legacy SD operation functions. + * + */ +static void sd_uhs2_cmd_assemble(struct mmc_command *cmd, + struct uhs2_command *uhs2_cmd, + u8 plen, u8 resp_len) +{ + uhs2_cmd->payload_len =3D plen * sizeof(u32); + uhs2_cmd->packet_len =3D uhs2_cmd->payload_len + 4; + + cmd->uhs2_cmd =3D uhs2_cmd; + cmd->uhs2_cmd->uhs2_resp_len =3D resp_len; +} + /* * Run the phy initialization sequence, which mainly relies on the UHS-II = host * to check that we reach the expected electrical state, between the host = and @@ -55,7 +117,15 @@ static int sd_uhs2_power_off(struct mmc_host *host) */ static int sd_uhs2_phy_init(struct mmc_host *host) { - return 0; + int err; + + err =3D host->ops->uhs2_control(host, UHS2_PHY_INIT); + if (err) { + pr_err("%s: failed to initial phy for UHS-II!\n", + mmc_hostname(host)); + } + + return err; } =20 /* @@ -64,6 +134,83 @@ static int sd_uhs2_phy_init(struct mmc_host *host) */ static int sd_uhs2_dev_init(struct mmc_host *host) { + struct mmc_command cmd =3D {0}; + struct uhs2_command uhs2_cmd =3D {}; + u32 cnt; + u32 dap, gap, resp_gap; + u8 gd =3D 0; + int err; + + dap =3D host->uhs2_caps.dap; + gap =3D host->uhs2_caps.gap; + + /* + * Refer to UHS-II Addendum Version 1.02 Figure 6-21 to see DEVICE_INIT C= CMD format. + * Head: + * - Control Write(R/W=3D1) with 4-Byte payload(PLEN=3D01b). + * - IOADR =3D CMD_BASE + 002h + * Payload: + * - bit [3:0] : GAP(Group Allocated Power) + * - bit [7:4] : GD(Group Descriptor) + * - bit [11] : Complete Flag + * - bit [15:12]: DAP(Device Allocated Power) + */ + uhs2_cmd.header =3D UHS2_NATIVE_PACKET | UHS2_PACKET_TYPE_CCMD; + uhs2_cmd.arg =3D ((UHS2_DEV_CMD_DEVICE_INIT & 0xFF) << 8) | + UHS2_NATIVE_CMD_WRITE | + UHS2_NATIVE_CMD_PLEN_4B | + (UHS2_DEV_CMD_DEVICE_INIT >> 8); + + /* + * Refer to UHS-II Addendum Version 1.02 section 6.3.1. + * Max. time from DEVICE_INIT CCMD EOP reception on Device + * Rx to its SOP transmission on Device Tx(Tfwd_init_cmd) is + * 1 second. + */ + cmd.busy_timeout =3D 1000; + + /* + * Refer to UHS-II Addendum Version 1.02 section 6.2.6.3. + * Let's retry the DEVICE_INIT command no more than 30 times. + */ + for (cnt =3D 0; cnt < 30; cnt++) { + uhs2_cmd.payload[0] =3D ((dap & 0xF) << 12) | + UHS2_DEV_INIT_COMPLETE_FLAG | + ((gd & 0xF) << 4) | + (gap & 0xF); + + sd_uhs2_cmd_assemble(&cmd, &uhs2_cmd, UHS2_DEV_INIT_PAYLOAD_LEN, + UHS2_DEV_INIT_RESP_LEN); + + err =3D mmc_wait_for_cmd(host, &cmd, 0); + + if (err) { + pr_err("%s: %s: UHS2 CMD send fail, err=3D 0x%x!\n", + mmc_hostname(host), __func__, err); + continue; + } + + if (uhs2_cmd.uhs2_resp[3] !=3D (UHS2_DEV_CMD_DEVICE_INIT & 0xFF)) { + pr_err("%s: DEVICE_INIT response is wrong!\n", + mmc_hostname(host)); + return -EIO; + } + + if (uhs2_cmd.uhs2_resp[5] & 0x8) { + host->uhs2_caps.group_desc =3D gd; + return 0; + } + resp_gap =3D uhs2_cmd.uhs2_resp[4] & 0x0F; + if (gap =3D=3D resp_gap) + gd++; + } + + if (err) { + pr_err("%s: %s: UHS2 CMD send fail, err=3D 0x%x!\n", + mmc_hostname(host), __func__, err); + return err; + } + return 0; } =20 @@ -74,6 +221,48 @@ static int sd_uhs2_dev_init(struct mmc_host *host) */ static int sd_uhs2_enum(struct mmc_host *host, u32 *node_id) { + struct mmc_command cmd =3D {0}; + struct uhs2_command uhs2_cmd =3D {}; + u8 id_f =3D 0xF, id_l =3D 0x0; + int err; + + /* + * Refer to UHS-II Addendum Version 1.02 Figure 6-28 to see ENUMERATE CCM= D format. + * Header: + * - Control Write(R/W=3D1) with 4-Byte payload(PLEN=3D01b). + * - IOADR =3D CMD_BASE + 003h + * Payload: + * - bit [3:0]: ID_L(Last Node ID) + * - bit [7:4]: ID_F(First Node ID) + */ + uhs2_cmd.header =3D UHS2_NATIVE_PACKET | UHS2_PACKET_TYPE_CCMD; + uhs2_cmd.arg =3D ((UHS2_DEV_CMD_ENUMERATE & 0xFF) << 8) | + UHS2_NATIVE_CMD_WRITE | + UHS2_NATIVE_CMD_PLEN_4B | + (UHS2_DEV_CMD_ENUMERATE >> 8); + + uhs2_cmd.payload[0] =3D (id_f << 4) | id_l; + uhs2_cmd.payload[0] =3D cpu_to_be32(uhs2_cmd.payload[0]); + + sd_uhs2_cmd_assemble(&cmd, &uhs2_cmd, UHS2_DEV_ENUM_PAYLOAD_LEN, UHS2_DEV= _ENUM_RESP_LEN); + + err =3D mmc_wait_for_cmd(host, &cmd, 0); + if (err) { + pr_err("%s: %s: UHS2 CMD send fail, err=3D 0x%x!\n", + mmc_hostname(host), __func__, err); + return err; + } + + if (uhs2_cmd.uhs2_resp[3] !=3D (UHS2_DEV_CMD_ENUMERATE & 0xFF)) { + pr_err("%s: ENUMERATE response is wrong!\n", + mmc_hostname(host)); + return -EIO; + } + + id_f =3D (uhs2_cmd.uhs2_resp[4] >> 4) & 0xF; + id_l =3D uhs2_cmd.uhs2_resp[4] & 0xF; + *node_id =3D id_f; + return 0; } =20 @@ -84,6 +273,180 @@ static int sd_uhs2_enum(struct mmc_host *host, u32 *no= de_id) */ static int sd_uhs2_config_read(struct mmc_host *host, struct mmc_card *car= d) { + struct mmc_command cmd =3D {0}; + struct uhs2_command uhs2_cmd =3D {}; + u32 cap; + int err; + + /* + * Use Control Read CCMD to read Generic Capability from Configuration Re= gister. + * - Control Write(R/W=3D1) with 4-Byte payload(PLEN=3D01b). + * - IOADR =3D Generic Capability Register(CFG_BASE + 000h) + */ + uhs2_cmd.header =3D UHS2_NATIVE_PACKET | UHS2_PACKET_TYPE_CCMD | card->uh= s2_config.node_id; + uhs2_cmd.arg =3D ((UHS2_DEV_CONFIG_GEN_CAPS & 0xFF) << 8) | + UHS2_NATIVE_CMD_READ | + UHS2_NATIVE_CMD_PLEN_4B | + (UHS2_DEV_CONFIG_GEN_CAPS >> 8); + + /* + * There is no payload because per spec, there should be + * no payload field for read CCMD. + * Plen is set in arg. Per spec, plen for read CCMD + * represents the len of read data which is assigned in payload + * of following RES (p136). + */ + sd_uhs2_cmd_assemble(&cmd, &uhs2_cmd, 0, 0); + + err =3D mmc_wait_for_cmd(host, &cmd, 0); + if (err) { + pr_err("%s: %s: UHS2 CMD send fail, err=3D 0x%x!\n", + mmc_hostname(host), __func__, err); + return err; + } + + /* + * Generic Capability Register: + * bit [7:0] : Reserved + * bit [13:8] : Device-Specific Number of Lanes and Functionality + * bit 8: 2L-HD + * bit 9: 2D-1U FD + * bit 10: 1D-2U FD + * bit 11: 2D-2U FD + * Others: Reserved + * bit [14] : DADR Length + * 0: 4 bytes + * 1: Reserved + * bit [23:16]: Application Type + * bit 16: 0=3DNon-SD memory, 1=3DSD memory + * bit 17: 0=3DNon-SDIO, 1=3DSDIO + * bit 18: 0=3DCard, 1=3DEmbedded + * bit [63:24]: Reserved + */ + cap =3D cmd.resp[0]; + card->uhs2_config.n_lanes =3D + (cap >> UHS2_DEV_CONFIG_N_LANES_POS) & + UHS2_DEV_CONFIG_N_LANES_MASK; + card->uhs2_config.dadr_len =3D + (cap >> UHS2_DEV_CONFIG_DADR_POS) & + UHS2_DEV_CONFIG_DADR_MASK; + card->uhs2_config.app_type =3D + (cap >> UHS2_DEV_CONFIG_APP_POS) & + UHS2_DEV_CONFIG_APP_MASK; + + /* + * Use Control Read CCMD to read PHY Capability from Configuration Regist= er. + * - Control Write(R/W=3D1) with 8-Byte payload(PLEN=3D10b). + * - IOADR =3D PHY Capability Register(CFG_BASE + 002h) + */ + uhs2_cmd.arg =3D ((UHS2_DEV_CONFIG_PHY_CAPS & 0xFF) << 8) | + UHS2_NATIVE_CMD_READ | + UHS2_NATIVE_CMD_PLEN_8B | + (UHS2_DEV_CONFIG_PHY_CAPS >> 8); + + sd_uhs2_cmd_assemble(&cmd, &uhs2_cmd, 0, 0); + + err =3D mmc_wait_for_cmd(host, &cmd, 0); + if (err) { + pr_err("%s: %s: UHS2 CMD send fail, err=3D 0x%x!\n", + mmc_hostname(host), __func__, err); + return err; + } + + /* + * PHY Capability Register: + * bit [3:0] : PHY Minor Revision + * bit [5:4] : PHY Major Revision + * bit [15] : Support Hibernate Mode + * 0: Not support Hibernate Mode + * 1: Support Hibernate Mode + * bit [31:16]: Reserved + * bit [35:32]: Device-Specific N_LSS_SYN + * bit [39:36]: Device-Specific N_LSS_DIR + * bit [63:40]: Reserved + */ + cap =3D cmd.resp[0]; + card->uhs2_config.phy_minor_rev =3D + cap & UHS2_DEV_CONFIG_PHY_MINOR_MASK; + card->uhs2_config.phy_major_rev =3D + (cap >> UHS2_DEV_CONFIG_PHY_MAJOR_POS) & + UHS2_DEV_CONFIG_PHY_MAJOR_MASK; + card->uhs2_config.can_hibernate =3D + (cap >> UHS2_DEV_CONFIG_CAN_HIBER_POS) & + UHS2_DEV_CONFIG_CAN_HIBER_MASK; + + cap =3D cmd.resp[1]; + card->uhs2_config.n_lss_sync =3D + cap & UHS2_DEV_CONFIG_N_LSS_SYN_MASK; + card->uhs2_config.n_lss_dir =3D + (cap >> UHS2_DEV_CONFIG_N_LSS_DIR_POS) & + UHS2_DEV_CONFIG_N_LSS_DIR_MASK; + if (card->uhs2_config.n_lss_sync =3D=3D 0) + card->uhs2_config.n_lss_sync =3D 16 << 2; + else + card->uhs2_config.n_lss_sync <<=3D 2; + + if (card->uhs2_config.n_lss_dir =3D=3D 0) + card->uhs2_config.n_lss_dir =3D 16 << 3; + else + card->uhs2_config.n_lss_dir <<=3D 3; + + /* + * Use Control Read CCMD to read LINK/TRAN Capability from Configuration = Register. + * - Control Write(R/W=3D1) with 8-Byte payload(PLEN=3D10b). + * - IOADR =3D LINK/TRAN Capability Register(CFG_BASE + 004h) + */ + uhs2_cmd.arg =3D ((UHS2_DEV_CONFIG_LINK_TRAN_CAPS & 0xFF) << 8) | + UHS2_NATIVE_CMD_READ | + UHS2_NATIVE_CMD_PLEN_8B | + (UHS2_DEV_CONFIG_LINK_TRAN_CAPS >> 8); + + sd_uhs2_cmd_assemble(&cmd, &uhs2_cmd, 0, 0); + + err =3D mmc_wait_for_cmd(host, &cmd, 0); + if (err) { + pr_err("%s: %s: UHS2 CMD send fail, err=3D 0x%x!\n", + mmc_hostname(host), __func__, err); + return err; + } + + /* + * LINK/TRAN Capability Register: + * bit [3:0] : LINK_TRAN Minor Revision + * bit [5:4] : LINK/TRAN Major Revision + * bit [7:6] : Reserved + * bit [15:8] : Device-Specific N_FCU + * bit [18:16]: Device Type + * 001b=3DHost + * 010b=3DDevice + * 011b=3DReserved for CMD issuable Device + * bit [19] : Reserved + * bit [31:20]: Device-Specific MAX_BLKLEN + * bit [39:32]: Device-Specific N_DATA_GAP + * bit [63:40]: Reserved + */ + cap =3D cmd.resp[0]; + card->uhs2_config.link_minor_rev =3D + cap & UHS2_DEV_CONFIG_LT_MINOR_MASK; + card->uhs2_config.link_major_rev =3D + (cap >> UHS2_DEV_CONFIG_LT_MAJOR_POS) & + UHS2_DEV_CONFIG_LT_MAJOR_MASK; + card->uhs2_config.n_fcu =3D + (cap >> UHS2_DEV_CONFIG_N_FCU_POS) & + UHS2_DEV_CONFIG_N_FCU_MASK; + card->uhs2_config.dev_type =3D + (cap >> UHS2_DEV_CONFIG_DEV_TYPE_POS) & + UHS2_DEV_CONFIG_DEV_TYPE_MASK; + card->uhs2_config.maxblk_len =3D + (cap >> UHS2_DEV_CONFIG_MAX_BLK_LEN_POS) & + UHS2_DEV_CONFIG_MAX_BLK_LEN_MASK; + + cap =3D cmd.resp[1]; + card->uhs2_config.n_data_gap =3D + cap & UHS2_DEV_CONFIG_N_DATA_GAP_MASK; + if (card->uhs2_config.n_fcu =3D=3D 0) + card->uhs2_config.n_fcu =3D 256; + return 0; } =20 @@ -98,26 +461,350 @@ static int sd_uhs2_config_read(struct mmc_host *host,= struct mmc_card *card) */ static int sd_uhs2_config_write(struct mmc_host *host, struct mmc_card *ca= rd) { + struct mmc_command cmd =3D {0}; + struct uhs2_command uhs2_cmd =3D {}; + u8 nMinDataGap; + int err; + + /* + * Use Control Write CCMD to set Generic Setting in Configuration Registe= r. + * - Control Write(R/W=3D1) with 8-Byte payload(PLEN=3D10b). + * - IOADR =3D Generic Setting Register(CFG_BASE + 008h) + * - Payload =3D New contents to be written to Generic Setting Register + */ + uhs2_cmd.header =3D UHS2_NATIVE_PACKET | UHS2_PACKET_TYPE_CCMD | card->uh= s2_config.node_id; + uhs2_cmd.arg =3D ((UHS2_DEV_CONFIG_GEN_SET & 0xFF) << 8) | + UHS2_NATIVE_CMD_WRITE | + UHS2_NATIVE_CMD_PLEN_8B | + (UHS2_DEV_CONFIG_GEN_SET >> 8); + + /* + * Most UHS-II cards only support FD and 2L-HD mode. Other lane numbers + * defined in UHS-II addendem Ver1.01 are optional. + */ + host->uhs2_caps.n_lanes_set =3D UHS2_DEV_CONFIG_GEN_SET_2L_FD_HD; + card->uhs2_config.n_lanes_set =3D UHS2_DEV_CONFIG_GEN_SET_2L_FD_HD; + + uhs2_cmd.payload[0] =3D card->uhs2_config.n_lanes_set << UHS2_DEV_CONFIG_= N_LANES_POS; + uhs2_cmd.payload[1] =3D 0; + uhs2_cmd.payload[0] =3D cpu_to_be32(uhs2_cmd.payload[0]); + uhs2_cmd.payload[1] =3D cpu_to_be32(uhs2_cmd.payload[1]); + + /* + * There is no payload because per spec, there should be + * no payload field for read CCMD. + * Plen is set in arg. Per spec, plen for read CCMD + * represents the len of read data which is assigned in payload + * of following RES (p136). + */ + sd_uhs2_cmd_assemble(&cmd, &uhs2_cmd, UHS2_CFG_WRITE_PAYLOAD_LEN, 0); + + err =3D mmc_wait_for_cmd(host, &cmd, 0); + if (err) { + pr_err("%s: %s: UHS2 CMD send fail, err=3D 0x%x!\n", + mmc_hostname(host), __func__, err); + return err; + } + + /* + * Use Control Write CCMD to set PHY Setting in Configuration Register. + * - Control Write(R/W=3D1) with 8-Byte payload(PLEN=3D10b). + * - IOADR =3D PHY Setting Register(CFG_BASE + 00Ah) + * - Payload =3D New contents to be written to PHY Setting Register + */ + uhs2_cmd.arg =3D ((UHS2_DEV_CONFIG_PHY_SET & 0xFF) << 8) | + UHS2_NATIVE_CMD_WRITE | + UHS2_NATIVE_CMD_PLEN_8B | + (UHS2_DEV_CONFIG_PHY_SET >> 8); + + if (host->uhs2_caps.speed_range =3D=3D UHS2_DEV_CONFIG_PHY_SET_SPEED_B) { + if (card->uhs2_config.n_lanes =3D=3D UHS2_DEV_CONFIG_2L_HD_FD && + host->uhs2_caps.n_lanes =3D=3D UHS2_DEV_CONFIG_2L_HD_FD) { + /* Support HD */ + host->ios.timing =3D MMC_TIMING_UHS2_SPEED_B_HD; + nMinDataGap =3D 1; + } else { + /* Only support 2L-FD so far */ + host->ios.timing =3D MMC_TIMING_UHS2_SPEED_B; + nMinDataGap =3D 3; + } + card->uhs2_config.speed_range_set =3D UHS2_DEV_CONFIG_PHY_SET_SPEED_B; + } else { + if (card->uhs2_config.n_lanes =3D=3D UHS2_DEV_CONFIG_2L_HD_FD && + host->uhs2_caps.n_lanes =3D=3D UHS2_DEV_CONFIG_2L_HD_FD) { + /* Support HD */ + host->ios.timing =3D MMC_TIMING_UHS2_SPEED_A_HD; + nMinDataGap =3D 1; + } else { + /* Only support 2L-FD so far */ + host->ios.timing =3D MMC_TIMING_UHS2_SPEED_A; + nMinDataGap =3D 3; + } + card->uhs2_config.speed_range_set =3D UHS2_DEV_CONFIG_PHY_SET_SPEED_A; + } + + uhs2_cmd.payload[0] =3D + card->uhs2_config.speed_range_set << UHS2_DEV_CONFIG_PHY_SET_SPEED_POS; + + card->uhs2_config.n_lss_sync_set =3D (max(card->uhs2_config.n_lss_sync, + host->uhs2_caps.n_lss_sync) >> 2) & + UHS2_DEV_CONFIG_N_LSS_SYN_MASK; + host->uhs2_caps.n_lss_sync_set =3D card->uhs2_config.n_lss_sync_set; + + card->uhs2_config.n_lss_dir_set =3D (max(card->uhs2_config.n_lss_dir, + host->uhs2_caps.n_lss_dir) >> 3) & + UHS2_DEV_CONFIG_N_LSS_DIR_MASK; + host->uhs2_caps.n_lss_dir_set =3D card->uhs2_config.n_lss_dir_set; + + uhs2_cmd.payload[1] =3D (card->uhs2_config.n_lss_dir_set << UHS2_DEV_CONF= IG_N_LSS_DIR_POS) | + card->uhs2_config.n_lss_sync_set; + uhs2_cmd.payload[0] =3D cpu_to_be32(uhs2_cmd.payload[0]); + uhs2_cmd.payload[1] =3D cpu_to_be32(uhs2_cmd.payload[1]); + + memset(uhs2_cmd.uhs2_resp, 0, sizeof(uhs2_cmd.uhs2_resp)); + + sd_uhs2_cmd_assemble(&cmd, &uhs2_cmd, UHS2_CFG_WRITE_PAYLOAD_LEN, + UHS2_CFG_WRITE_PHY_SET_RESP_LEN); + + err =3D mmc_wait_for_cmd(host, &cmd, 0); + if (err) { + pr_err("%s: %s: UHS2 CMD send fail, err=3D 0x%x!\n", + mmc_hostname(host), __func__, err); + return err; + } + + if ((uhs2_cmd.uhs2_resp[2] & 0x80)) { + pr_err("%s: %s: UHS2 CMD not accepted, resp=3D 0x%x!\n", + mmc_hostname(host), __func__, uhs2_cmd.uhs2_resp[2]); + return -EIO; + } + + /* + * Use Control Write CCMD to set LINK/TRAN Setting in Configuration Regis= ter. + * - Control Write(R/W=3D1) with 8-Byte payload(PLEN=3D10b). + * - IOADR =3D LINK/TRAN Setting Register(CFG_BASE + 00Ch) + * - Payload =3D New contents to be written to LINK/TRAN Setting Register + */ + uhs2_cmd.arg =3D ((UHS2_DEV_CONFIG_LINK_TRAN_SET & 0xFF) << 8) | + UHS2_NATIVE_CMD_WRITE | + UHS2_NATIVE_CMD_PLEN_8B | + (UHS2_DEV_CONFIG_LINK_TRAN_SET >> 8); + + if (card->uhs2_config.app_type =3D=3D UHS2_DEV_CONFIG_APP_SD_MEM) + card->uhs2_config.maxblk_len_set =3D UHS2_DEV_CONFIG_LT_SET_MAX_BLK_LEN; + else + card->uhs2_config.maxblk_len_set =3D min(card->uhs2_config.maxblk_len, + host->uhs2_caps.maxblk_len); + host->uhs2_caps.maxblk_len_set =3D card->uhs2_config.maxblk_len_set; + + card->uhs2_config.n_fcu_set =3D min(card->uhs2_config.n_fcu, host->uhs2_c= aps.n_fcu); + host->uhs2_caps.n_fcu_set =3D card->uhs2_config.n_fcu_set; + + card->uhs2_config.n_data_gap_set =3D max(nMinDataGap, card->uhs2_config.n= _data_gap); + host->uhs2_caps.n_data_gap_set =3D card->uhs2_config.n_data_gap_set; + + host->uhs2_caps.max_retry_set =3D 3; + card->uhs2_config.max_retry_set =3D host->uhs2_caps.max_retry_set; + + uhs2_cmd.payload[0] =3D + (card->uhs2_config.maxblk_len_set << UHS2_DEV_CONFIG_MAX_BLK_LEN_POS) | + (card->uhs2_config.max_retry_set << UHS2_DEV_CONFIG_LT_SET_MAX_RETRY_PO= S) | + (card->uhs2_config.n_fcu_set << UHS2_DEV_CONFIG_N_FCU_POS); + uhs2_cmd.payload[1] =3D card->uhs2_config.n_data_gap_set; + uhs2_cmd.payload[0] =3D cpu_to_be32(uhs2_cmd.payload[0]); + uhs2_cmd.payload[1] =3D cpu_to_be32(uhs2_cmd.payload[1]); + + sd_uhs2_cmd_assemble(&cmd, &uhs2_cmd, UHS2_CFG_WRITE_PAYLOAD_LEN, 0); + + err =3D mmc_wait_for_cmd(host, &cmd, 0); + if (err) { + pr_err("%s: %s: UHS2 CMD send fail, err=3D 0x%x!\n", + mmc_hostname(host), __func__, err); + return err; + } + + /* + * Use Control Write CCMD to set Config Completion(payload bit 63) in Gen= eric Setting + * Register. + * Header: + * - Control Write(R/W=3D1) with 8-Byte payload(PLEN=3D10b). + * - IOADR =3D PGeneric Setting Register(CFG_BASE + 008h) + * Payload: + * - bit [63]: Config Completion + * + * DLSM transits to Active state immediately when Config Completion is se= t to 1. + */ + uhs2_cmd.arg =3D ((UHS2_DEV_CONFIG_GEN_SET & 0xFF) << 8) | + UHS2_NATIVE_CMD_WRITE | + UHS2_NATIVE_CMD_PLEN_8B | + (UHS2_DEV_CONFIG_GEN_SET >> 8); + + uhs2_cmd.payload[0] =3D 0; + uhs2_cmd.payload[1] =3D UHS2_DEV_CONFIG_GEN_SET_CFG_COMPLETE; + uhs2_cmd.payload[0] =3D cpu_to_be32(uhs2_cmd.payload[0]); + uhs2_cmd.payload[1] =3D cpu_to_be32(uhs2_cmd.payload[1]); + + memset(uhs2_cmd.uhs2_resp, 0, sizeof(uhs2_cmd.uhs2_resp)); + sd_uhs2_cmd_assemble(&cmd, &uhs2_cmd, UHS2_CFG_WRITE_PAYLOAD_LEN, + UHS2_CFG_WRITE_GENERIC_SET_RESP_LEN); + + err =3D mmc_wait_for_cmd(host, &cmd, 0); + if (err) { + pr_err("%s: %s: UHS2 CMD send fail, err=3D 0x%x!\n", + mmc_hostname(host), __func__, err); + return err; + } + + /* Set host Config Setting registers */ + err =3D host->ops->uhs2_control(host, UHS2_SET_CONFIG); + if (err) { + pr_err("%s: %s: UHS2 SET_CONFIG fail!\n", mmc_hostname(host), __func__); + return err; + } + return 0; } =20 -/* - * Initialize the UHS-II card through the SD-TRAN transport layer. This en= ables - * commands/requests to be backwards compatible through the legacy SD prot= ocol. - * UHS-II cards has a specific power limit specified for VDD1/VDD2, that s= hould - * be set through a legacy CMD6. Note that, the power limit that becomes s= et, - * survives a soft reset through the GO_DORMANT_STATE command. - */ -static int sd_uhs2_legacy_init(struct mmc_host *host, struct mmc_card *car= d) +static int sd_uhs2_go_dormant(struct mmc_host *host, u32 node_id) +{ + struct mmc_command cmd =3D {0}; + struct uhs2_command uhs2_cmd =3D {}; + int err; + + /* Disable Normal INT */ + err =3D host->ops->uhs2_control(host, UHS2_DISABLE_INT); + if (err) { + pr_err("%s: %s: UHS2 DISABLE_INT fail!\n", + mmc_hostname(host), __func__); + return err; + } + + /* + * Refer to UHS-II Addendum Version 1.02 Figure 6-17 to see GO_DORMANT_ST= ATE CCMD format. + * Header: + * - Control Write(R/W=3D1) with 4-Byte payload(PLEN=3D01b). + * - IOADR =3D CMD_BASE + 001h + * Payload: + * - bit [7]: HBR(Entry to Hibernate Mode) + * 1: Host intends to enter Hibernate mode during Dormant= state. + * The default setting is 0 because hibernate is currentl= y not supported. + */ + uhs2_cmd.header =3D UHS2_NATIVE_PACKET | UHS2_PACKET_TYPE_CCMD | node_id; + uhs2_cmd.arg =3D ((UHS2_DEV_CMD_GO_DORMANT_STATE & 0xFF) << 8) | + UHS2_NATIVE_CMD_WRITE | + UHS2_NATIVE_CMD_PLEN_4B | + (UHS2_DEV_CMD_GO_DORMANT_STATE >> 8); + + sd_uhs2_cmd_assemble(&cmd, &uhs2_cmd, UHS2_GO_DORMANT_PAYLOAD_LEN, 0); + + err =3D mmc_wait_for_cmd(host, &cmd, 0); + if (err) { + pr_err("%s: %s: UHS2 CMD send fail, err=3D 0x%x!\n", + mmc_hostname(host), __func__, err); + return err; + } + + /* Check Dormant State in Present */ + err =3D host->ops->uhs2_control(host, UHS2_CHECK_DORMANT); + if (err) + return err; + + /* Disable UHS2 card clock */ + err =3D host->ops->uhs2_control(host, UHS2_DISABLE_CLK); + if (err) + return err; + + /* Restore sd clock */ + mmc_delay(5); + err =3D host->ops->uhs2_control(host, UHS2_ENABLE_CLK); + if (err) + return err; + + /* Enable Normal INT */ + err =3D host->ops->uhs2_control(host, UHS2_ENABLE_INT); + if (err) + return err; + + /* Detect UHS2 */ + err =3D host->ops->uhs2_control(host, UHS2_PHY_INIT); + if (err) + return err; + + return 0; +} + +static int sd_uhs2_wait_active_state_cb(void *cb_data, bool *busy) +{ + struct sd_uhs2_wait_active_state_data *data =3D cb_data; + struct mmc_host *host =3D data->host; + struct mmc_command *cmd =3D data->cmd; + int err; + + err =3D mmc_wait_for_cmd(host, cmd, 0); + if (err) + return err; + + if (cmd->resp[1] & UHS2_DEV_CONFIG_GEN_SET_CFG_COMPLETE) + *busy =3D false; + else + *busy =3D true; + + return 0; +} + +static int sd_uhs2_go_dormant_state(struct mmc_host *host, u32 node_id) { + struct mmc_command cmd =3D {0}; + struct uhs2_command uhs2_cmd =3D {}; + int err; + struct sd_uhs2_wait_active_state_data cb_data =3D { + .host =3D host, + .cmd =3D &cmd + }; + + err =3D sd_uhs2_go_dormant(host, node_id); + if (err) { + pr_err("%s: %s: UHS2 GO_DORMANT_STATE fail, err=3D 0x%x!\n", + mmc_hostname(host), __func__, err); + return err; + } + + /* + * Use Control Read CCMD to check Config Completion(bit 63) in Generic Se= tting Register. + * - Control Read(R/W=3D0) with 8-Byte payload(PLEN=3D10b). + * - IOADR =3D Generic Setting Register(CFG_BASE + 008h) + * + * When UHS-II card been switched to new speed mode, it will set Config C= ompletion to 1. + */ + uhs2_cmd.header =3D UHS2_NATIVE_PACKET | UHS2_PACKET_TYPE_CCMD | node_id; + uhs2_cmd.arg =3D ((UHS2_DEV_CONFIG_GEN_SET & 0xFF) << 8) | + UHS2_NATIVE_CMD_READ | + UHS2_NATIVE_CMD_PLEN_8B | + (UHS2_DEV_CONFIG_GEN_SET >> 8); + + sd_uhs2_cmd_assemble(&cmd, &uhs2_cmd, 0, 0); + err =3D __mmc_poll_for_busy(host, UHS2_WAIT_CFG_COMPLETE_PERIOD_US, + UHS2_WAIT_CFG_COMPLETE_TIMEOUT_MS, + &sd_uhs2_wait_active_state_cb, &cb_data); + if (err) { + pr_err("%s: %s: Not switch to Active in 100 ms\n", mmc_hostname(host), _= _func__); + return err; + } + return 0; } =20 +static void sd_uhs2_remove(struct mmc_host *host) +{ + mmc_remove_card(host->card); + host->card =3D NULL; +} + /* * Allocate the data structure for the mmc_card and run the UHS-II specific * initialization sequence. */ -static int sd_uhs2_init_card(struct mmc_host *host) +static int sd_uhs2_init_card(struct mmc_host *host, struct mmc_card *oldca= rd) { struct mmc_card *card; u32 node_id; @@ -131,9 +818,14 @@ static int sd_uhs2_init_card(struct mmc_host *host) if (err) return err; =20 - card =3D mmc_alloc_card(host, &sd_type); - if (IS_ERR(card)) - return PTR_ERR(card); + if (oldcard) { + card =3D oldcard; + } else { + card =3D mmc_alloc_card(host, &sd_type); + if (IS_ERR(card)) + return PTR_ERR(card); + } + host->card =3D card; =20 card->uhs2_config.node_id =3D node_id; card->type =3D MMC_TYPE_SD; @@ -146,18 +838,189 @@ static int sd_uhs2_init_card(struct mmc_host *host) if (err) goto err; =20 - host->card =3D card; + /* If change speed to Range B, need to GO_DORMANT_STATE */ + if (host->ios.timing =3D=3D MMC_TIMING_UHS2_SPEED_B || + host->ios.timing =3D=3D MMC_TIMING_UHS2_SPEED_B_HD) { + err =3D sd_uhs2_go_dormant_state(host, node_id); + if (err) + goto err; + } + + host->uhs2_sd_tran =3D true; + return 0; =20 err: - mmc_remove_card(card); + if (!oldcard) + mmc_remove_card(card); + else + sd_uhs2_remove(host); return err; } =20 -static void sd_uhs2_remove(struct mmc_host *host) +/* + * Initialize the UHS-II card through the SD-TRAN transport layer. This en= ables + * commands/requests to be backwards compatible through the legacy SD prot= ocol. + * UHS-II cards has a specific power limit specified for VDD1/VDD2, that s= hould + * be set through a legacy CMD6. Note that, the power limit that becomes s= et, + * survives a soft reset through the GO_DORMANT_STATE command. + */ +static int sd_uhs2_legacy_init(struct mmc_host *host, struct mmc_card *car= d) { - mmc_remove_card(host->card); - host->card =3D NULL; + int err; + u32 cid[4]; + u32 ocr; + u32 rocr; + u8 *status; + int ro; + + /* Send CMD0 to reset SD card */ + err =3D __mmc_go_idle(host); + if (err) + return err; + + mmc_delay(1); + + /* Send CMD8 to communicate SD interface operation condition */ + err =3D mmc_send_if_cond(host, host->ocr_avail); + if (err) { + dev_warn(mmc_dev(host), "CMD8 error\n"); + goto err; + } + + /* + * Probe SD card working voltage. + */ + err =3D mmc_send_app_op_cond(host, 0, &ocr); + if (err) + goto err; + + card->ocr =3D ocr; + + /* + * Some SD cards claims an out of spec VDD voltage range. Let's treat + * these bits as being in-valid and especially also bit7. + */ + ocr &=3D ~0x7FFF; + rocr =3D mmc_select_voltage(host, ocr); + /* + * Some cards have zero value of rocr in UHS-II mode. Assign host's + * ocr value to rocr. + */ + if (!rocr) + rocr =3D host->ocr_avail; + + rocr |=3D (SD_OCR_CCS | SD_OCR_XPC); + + /* Wait SD power on ready */ + ocr =3D rocr; + + err =3D mmc_send_app_op_cond(host, ocr, &rocr); + if (err) + goto err; + + err =3D mmc_send_cid(host, cid); + if (err) + goto err; + + memcpy(card->raw_cid, cid, sizeof(card->raw_cid)); + mmc_decode_cid(card); + + /* + * For native busses: get card RCA and quit open drain mode. + */ + err =3D mmc_send_relative_addr(host, &card->rca); + if (err) + goto err; + + err =3D mmc_sd_get_csd(card); + if (err) + goto err; + + /* + * Select card, as all following commands rely on that. + */ + err =3D mmc_select_card(card); + if (err) + goto err; + + /* + * Fetch SCR from card. + */ + err =3D mmc_app_send_scr(card); + if (err) + goto err; + + err =3D mmc_decode_scr(card); + if (err) + goto err; + + /* + * Switch to high power consumption mode. + * Even switch failed, sd card can still work at lower power consumption = mode, but + * performance will be lower than high power consumption mode. + */ + status =3D kmalloc(64, GFP_KERNEL); + if (!status) + return -ENOMEM; + + if (!(card->csd.cmdclass & CCC_SWITCH)) { + pr_warn("%s: card lacks mandatory switch function, performance might suf= fer\n", + mmc_hostname(card->host)); + } else { + /* send CMD6 to set Maximum Power Consumption to get better performance = */ + err =3D mmc_sd_switch(card, 0, 3, SD4_SET_POWER_LIMIT_1_80W, status); + if (!err) + err =3D mmc_sd_switch(card, 1, 3, SD4_SET_POWER_LIMIT_1_80W, status); + + err =3D 0; + } + + /* + * Check if read-only switch is active. + */ + ro =3D mmc_sd_get_ro(host); + if (ro < 0) { + pr_warn("%s: host does not support read-only switch, assuming write-enab= le\n", + mmc_hostname(host)); + } else if (ro > 0) { + mmc_card_set_readonly(card); + } + + /* + * NOTE: + * Should we read Externsion Register to check power notification feature= here? + */ + + kfree(status); + + return 0; + +err: + sd_uhs2_remove(host); + return err; +} + +static int sd_uhs2_reinit(struct mmc_host *host) +{ + struct mmc_card *card =3D host->card; + int err; + + sd_uhs2_power_up(host); + err =3D sd_uhs2_phy_init(host); + if (err) + return err; + + err =3D sd_uhs2_init_card(host, card); + if (err) + return err; + + err =3D sd_uhs2_legacy_init(host, card); + if (err) + return err; + + mmc_card_set_present(card); + return err; } =20 static int sd_uhs2_alive(struct mmc_host *host) @@ -179,38 +1042,194 @@ static void sd_uhs2_detect(struct mmc_host *host) mmc_claim_host(host); mmc_detach_bus(host); sd_uhs2_power_off(host); + /* Remove UHS2 timing to indicate the end of UHS2 mode */ + host->ios.timing =3D MMC_TIMING_LEGACY; mmc_release_host(host); } } =20 +static int _sd_uhs2_suspend(struct mmc_host *host) +{ + struct mmc_card *card =3D host->card; + int err =3D 0; + + mmc_claim_host(host); + + if (mmc_card_suspended(card)) + goto out; + + if (mmc_sd_can_poweroff_notify(card)) + err =3D sd_poweroff_notify(card); + + if (!err) { + sd_uhs2_power_off(host); + mmc_card_set_suspended(card); + } + +out: + mmc_release_host(host); + return err; +} + +/* + * Callback for suspend + */ static int sd_uhs2_suspend(struct mmc_host *host) { - return 0; + int err; + + err =3D _sd_uhs2_suspend(host); + if (!err) { + pm_runtime_disable(&host->card->dev); + pm_runtime_set_suspended(&host->card->dev); + } + + return err; +} + +/* + * This function tries to determine if the same card is still present + * and, if so, restore all state to it. + */ +static int _mmc_sd_uhs2_resume(struct mmc_host *host) +{ + int err =3D 0; + + mmc_claim_host(host); + + if (!mmc_card_suspended(host->card)) + goto out; + + /* Power up UHS2 SD card and re-initialize it. */ + err =3D sd_uhs2_reinit(host); + mmc_card_clr_suspended(host->card); + +out: + mmc_release_host(host); + return err; } =20 +/* + * Callback for resume + */ static int sd_uhs2_resume(struct mmc_host *host) { + pm_runtime_enable(&host->card->dev); return 0; } =20 +/* + * Callback for runtime_suspend. + */ static int sd_uhs2_runtime_suspend(struct mmc_host *host) { - return 0; + int err; + + if (!(host->caps & MMC_CAP_AGGRESSIVE_PM)) + return 0; + + err =3D _sd_uhs2_suspend(host); + if (err) + pr_err("%s: error %d doing aggressive suspend\n", mmc_hostname(host), er= r); + + return err; } =20 static int sd_uhs2_runtime_resume(struct mmc_host *host) { - return 0; + int err; + + err =3D _mmc_sd_uhs2_resume(host); + if (err && err !=3D -ENOMEDIUM) + pr_err("%s: error %d doing runtime resume\n", mmc_hostname(host), err); + + return err; } =20 -static int sd_uhs2_shutdown(struct mmc_host *host) +static int sd_uhs2_hw_reset(struct mmc_host *host) { - return 0; + int err; + + sd_uhs2_power_off(host); + /* Wait at least 1 ms according to SD spec */ + mmc_delay(1); + sd_uhs2_power_up(host); + + err =3D sd_uhs2_reinit(host); + + return err; } =20 -static int sd_uhs2_hw_reset(struct mmc_host *host) +/* + * mmc_uhs2_prepare_cmd - prepare for SD command packet + * @host: MMC host + * @mrq: MMC request + * + * Initialize and fill in a header and a payload of SD command packet. + * The caller should allocate uhs2_command in host->cmd->uhs2_cmd in + * advance. + * + * Return: 0 on success, non-zero error on failure + */ +void mmc_uhs2_prepare_cmd(struct mmc_host *host, struct mmc_request *mrq) { - return 0; + struct mmc_command *cmd; + struct uhs2_command *uhs2_cmd; + u8 plen; + + cmd =3D mrq->cmd; + cmd->uhs2_cmd =3D &mrq->uhs2_cmd; + uhs2_cmd =3D cmd->uhs2_cmd; + uhs2_cmd->header =3D host->card->uhs2_config.node_id; + if ((cmd->flags & MMC_CMD_MASK) =3D=3D MMC_CMD_ADTC) + uhs2_cmd->header |=3D UHS2_PACKET_TYPE_DCMD; + else + uhs2_cmd->header |=3D UHS2_PACKET_TYPE_CCMD; + + uhs2_cmd->arg =3D cmd->opcode << UHS2_SD_CMD_INDEX_POS; + if (host->uhs2_app_cmd) { + uhs2_cmd->arg |=3D UHS2_SD_CMD_APP; + host->uhs2_app_cmd =3D false; + } + + /* + * UHS-II Addendum 7.2.1.2 + * Host may set DM to 1 for DCMD which supports multi-block read/write re= gardless of + * data transfer length (e.g., CMD18, CMD25). Otherwise, it shall not set= DM to 1. + * (e.g., CMD6, CMD17, CMD24). These rules are also applied to other mult= i-block read/write + * commands defined in other Part of SD specifications (for example, Host= may set DM to 1 + * for ACMD18 or ACMD25). + */ + if (mmc_op_multi(cmd->opcode)) + cmd->uhs2_cmd->tmode_half_duplex =3D mmc_card_uhs2_hd_mode(host); + else + cmd->uhs2_cmd->tmode_half_duplex =3D 0; + + uhs2_cmd =3D cmd->uhs2_cmd; + plen =3D 2; /* at the maximum */ + + if ((cmd->flags & MMC_CMD_MASK) =3D=3D MMC_CMD_ADTC && + cmd->uhs2_cmd->tmode_half_duplex) { + if (mmc_card_uhs2_hd_mode(host)) + uhs2_cmd->arg |=3D UHS2_DCMD_2L_HD_MODE; + + uhs2_cmd->arg |=3D UHS2_DCMD_LM_TLEN_EXIST; + + if (cmd->data->blocks =3D=3D 1 && + cmd->data->blksz !=3D 512 && + cmd->opcode !=3D MMC_READ_SINGLE_BLOCK && + cmd->opcode !=3D MMC_WRITE_BLOCK) { + uhs2_cmd->arg |=3D UHS2_DCMD_TLUM_BYTE_MODE; + uhs2_cmd->payload[1] =3D cpu_to_be32(cmd->data->blksz); + } else { + uhs2_cmd->payload[1] =3D cpu_to_be32(cmd->data->blocks); + } + } else { + plen =3D 1; + } + + uhs2_cmd->payload[0] =3D cpu_to_be32(cmd->arg); + sd_uhs2_cmd_assemble(cmd, uhs2_cmd, plen, 0); } =20 static const struct mmc_bus_ops sd_uhs2_ops =3D { @@ -221,7 +1240,7 @@ static const struct mmc_bus_ops sd_uhs2_ops =3D { .resume =3D sd_uhs2_resume, .runtime_suspend =3D sd_uhs2_runtime_suspend, .runtime_resume =3D sd_uhs2_runtime_resume, - .shutdown =3D sd_uhs2_shutdown, + .shutdown =3D sd_uhs2_suspend, .hw_reset =3D sd_uhs2_hw_reset, }; =20 @@ -237,7 +1256,7 @@ static int sd_uhs2_attach(struct mmc_host *host) if (err) goto err; =20 - err =3D sd_uhs2_init_card(host); + err =3D sd_uhs2_init_card(host, NULL); if (err) goto err; =20 @@ -254,21 +1273,33 @@ static int sd_uhs2_attach(struct mmc_host *host) goto remove_card; =20 mmc_claim_host(host); + return 0; =20 remove_card: - mmc_remove_card(host->card); - host->card =3D NULL; + sd_uhs2_remove(host); mmc_claim_host(host); - mmc_detach_bus(host); + err: + mmc_detach_bus(host); sd_uhs2_power_off(host); + /* Remove UHS2 timing to indicate the end of UHS2 mode */ + host->ios.timing =3D MMC_TIMING_LEGACY; return err; } =20 +/** + * mmc_attach_sd_uhs2 - select UHS2 interface + * @host: MMC host + * + * Try to select UHS2 interface and initialize the bus for a given + * frequency, @freq. + * + * Return: 0 on success, non-zero error on failure + */ int mmc_attach_sd_uhs2(struct mmc_host *host) { - int i, err =3D 0; + int i, err; =20 if (!(host->caps2 & MMC_CAP2_SD_UHS2)) return -EOPNOTSUPP; @@ -283,6 +1314,9 @@ int mmc_attach_sd_uhs2(struct mmc_host *host) */ for (i =3D 0; i < ARRAY_SIZE(sd_uhs2_freqs); i++) { host->f_init =3D sd_uhs2_freqs[i]; + pr_debug("%s: %s: trying to init UHS-II card at %u Hz\n", + mmc_hostname(host), __func__, host->f_init); + err =3D sd_uhs2_attach(host); if (!err) break; diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h index f0ac2e469b32..291f89e12c65 100644 --- a/include/linux/mmc/core.h +++ b/include/linux/mmc/core.h @@ -11,6 +11,20 @@ struct mmc_data; struct mmc_request; =20 +#define UHS2_MAX_PAYLOAD_LEN 2 +#define UHS2_MAX_RESP_LEN 20 + +struct uhs2_command { + u16 header; + u16 arg; + __be32 payload[UHS2_MAX_PAYLOAD_LEN]; + u8 payload_len; + u8 packet_len; + u8 tmode_half_duplex; + u8 uhs2_resp[UHS2_MAX_RESP_LEN]; /* UHS2 native cmd resp */ + u8 uhs2_resp_len; /* UHS2 native cmd resp len */ +}; + struct mmc_command { u32 opcode; u32 arg; @@ -96,6 +110,8 @@ struct mmc_command { unsigned int busy_timeout; /* busy detect timeout in ms */ struct mmc_data *data; /* data segment associated with cmd */ struct mmc_request *mrq; /* associated request */ + + struct uhs2_command *uhs2_cmd; /* UHS2 command */ }; =20 struct mmc_data { @@ -154,6 +170,7 @@ struct mmc_request { const struct bio_crypt_ctx *crypto_ctx; int crypto_key_slot; #endif + struct uhs2_command uhs2_cmd; }; =20 struct mmc_card; diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h index 0e1112ee160e..4b9e23f2afee 100644 --- a/include/linux/mmc/host.h +++ b/include/linux/mmc/host.h @@ -126,6 +126,13 @@ struct sd_uhs2_caps { }; =20 enum sd_uhs2_operation { + UHS2_PHY_INIT =3D 0, + UHS2_SET_CONFIG, + UHS2_ENABLE_INT, + UHS2_DISABLE_INT, + UHS2_ENABLE_CLK, + UHS2_DISABLE_CLK, + UHS2_CHECK_DORMANT, UHS2_SET_IOS, }; =20 @@ -452,6 +459,8 @@ struct mmc_host { #endif #define MMC_CAP2_ALT_GPT_TEGRA (1 << 28) /* Host with eMMC that has GPT en= try at a non-standard location */ =20 + bool uhs2_sd_tran; + bool uhs2_app_cmd; /* Host UHS-II APP Command */ struct sd_uhs2_caps uhs2_caps; /* Host UHS-II capabilities */ =20 int fixed_drv_type; /* fixed driver type for non-removable media */ @@ -713,6 +722,12 @@ static inline void mmc_debugfs_err_stats_inc(struct mm= c_host *host, host->err_stats[stat] +=3D 1; } =20 +static inline int mmc_card_uhs2_hd_mode(struct mmc_host *host) +{ + return host->ios.timing =3D=3D MMC_TIMING_UHS2_SPEED_A_HD || + host->ios.timing =3D=3D MMC_TIMING_UHS2_SPEED_B_HD; +} + int mmc_sd_switch(struct mmc_card *card, bool mode, int group, u8 value, u8 *resp); int mmc_send_status(struct mmc_card *card, u32 *status); --=20 2.25.1