Skip to contentSkip to conversation

Add modules for realtek USB card reader

PATCH Superseded [email protected] 4 participants 13 messages Feb 6, 2014 – Feb 12, 2014 2 messages not in the archive

Subsystems (3)

v3 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

v3 cover Add modules for realtek USB card reader

From: Roger Tseng <[email protected]>

This patchset adds modules to support Realtek USB vendor specific class flash card reader: one base module in MFD subsystem and two host modules in both mmc and memstick subsystems. The architecture is similar to rtsx_pci.

This work is done primarily to replace the staging driver: staging/rts5139, which doesn't utilize mmc nor memstick subsystems. Once the patchset or its revision is applied, we may need Greg's help to remove the staging one.

v2:
1. Fix potential buffer overflow in rtsx_usb_seq_write_register()
2. Remove unnecessary casting and messages
3. Revise coding style and white spaces

v3:
1. Fix MMC detection fail when under xhci
2. Minor change of pm_runtime behavior in rtsx_usb_ms to prevent some rare freeze due to erroneous Memstick card(not MS-Pro)
3. Further revise coding style as suggested in the thread of v2
4. Using managed resources: devm_*
5. Change license from "GPL v2 and later" to "GPL v2"

Roger Tseng (3):
mfd: Add realtek USB card reader driver
mmc: Add realtek USB sdmmc host driver
memstick: Add realtek USB memstick host driver

 drivers/memstick/host/Kconfig       |   10 +
 drivers/memstick/host/Makefile      |    1 +
 drivers/memstick/host/rtsx_usb_ms.c |  849 ++++++++++++++++++++
 drivers/mfd/Kconfig                 |   10 +
 drivers/mfd/Makefile                |    1 +
 drivers/mfd/rtsx_usb.c              |  760 ++++++++++++++++++
 drivers/mmc/host/Kconfig            |    7 +
 drivers/mmc/host/Makefile           |    1 +
 drivers/mmc/host/rtsx_usb_sdmmc.c   | 1500 +++++++++++++++++++++++++++++++++++
 include/linux/mfd/rtsx_usb.h        |  628 +++++++++++++++
 10 files changed, 3767 insertions(+)
 create mode 100644 drivers/memstick/host/rtsx_usb_ms.c
 create mode 100644 drivers/mfd/rtsx_usb.c
 create mode 100644 drivers/mmc/host/rtsx_usb_sdmmc.c
 create mode 100644 include/linux/mfd/rtsx_usb.h
Signature · 1 line
1.8.2
#1 lore raw

PATCH v3 1/3 mfd: Add realtek USB card reader driver

From: Roger Tseng <[email protected]>

Realtek USB card reader provides a channel to transfer command or data to flash memory cards. This driver exports host instances for mmc and memstick subsystems and handles basic works.

---
 drivers/mfd/Kconfig          |  10 +
 drivers/mfd/Makefile         |   1 +
 drivers/mfd/rtsx_usb.c       | 760 +++++++++++++++++++++++++++++++++++++++++++
 include/linux/mfd/rtsx_usb.h | 628 +++++++++++++++++++++++++++++++++++
 4 files changed, 1399 insertions(+)
 create mode 100644 drivers/mfd/rtsx_usb.c
 create mode 100644 include/linux/mfd/rtsx_usb.h
drivers/mfd/Kconfig +10 -0
index b7c74a7..fabad24 100644
@@ -507,6 +507,16 @@ config MFD_RTSX_PCI
 	  types of memory cards, such as Memory Stick, Memory Stick Pro,
 	  Secure Digital and MultiMediaCard.
 
+config MFD_RTSX_USB
+	tristate "Realtek USB card reader"
+	depends on USB
+	select MFD_CORE
+	help
+	  Select this option to get support for Realtek USB 2.0 card readers
+	  including RTS5129, RTS5139, RTS5179 and RTS5170.
+	  Realtek card reader supports access to many types of memory cards,
+	  such as Memory Stick Pro, Secure Digital and MultiMediaCard.
+
 config MFD_RC5T583
 	bool "Ricoh RC5T583 Power Management system device"
 	depends on I2C=y
drivers/mfd/Makefile +1 -0
index 8a28dc9..33b8de6 100644
@@ -14,6 +14,7 @@ obj-$(CONFIG_MFD_CROS_EC_SPI)	+= cros_ec_spi.o
 
 rtsx_pci-objs			:= rtsx_pcr.o rts5209.o rts5229.o rtl8411.o rts5227.o rts5249.o
 obj-$(CONFIG_MFD_RTSX_PCI)	+= rtsx_pci.o
+obj-$(CONFIG_MFD_RTSX_USB)	+= rtsx_usb.o
 
 obj-$(CONFIG_HTC_EGPIO)		+= htc-egpio.o
 obj-$(CONFIG_HTC_PASIC3)	+= htc-pasic3.o
drivers/mfd/rtsx_usb.c new file +760 -0

760 lines not on this page · raw message

include/linux/mfd/rtsx_usb.h new file +628 -0

628 lines not on this page · raw message

Signature · 1 line
1.8.2
#2 lore raw

Re: [PATCH v3 1/3] mfd: Add realtek USB card reader driver

Quoted 7 lines

From: Roger Tseng <[email protected]>

Realtek USB card reader provides a channel to transfer command or data to flash memory cards. This driver exports host instances for mmc and memstick subsystems and handles basic works.

Quoted 8 lines
---
 drivers/mfd/Kconfig          |  10 +
 drivers/mfd/Makefile         |   1 +
 drivers/mfd/rtsx_usb.c       | 760 +++++++++++++++++++++++++++++++++++++++++++
 include/linux/mfd/rtsx_usb.h | 628 +++++++++++++++++++++++++++++++++++
 4 files changed, 1399 insertions(+)
 create mode 100644 drivers/mfd/rtsx_usb.c
 create mode 100644 include/linux/mfd/rtsx_usb.h

Applied with Greg's Ack.

Signature · 4 lines
Lee Jones
Linaro STMicroelectronics Landing Team Lead
Linaro.org │ Open source software for ARM SoCs
Follow Linaro: Facebook | Twitter | Blog
author
#3 lore raw

Re: [PATCH v3 1/3] mfd: Add realtek USB card reader driver

Quoted 16 lines · Lee Jones
Quoted 7 lines

From: Roger Tseng <[email protected]>

Realtek USB card reader provides a channel to transfer command or data to flash memory cards. This driver exports host instances for mmc and memstick subsystems and handles basic works.

Quoted 8 lines
---
  drivers/mfd/Kconfig          |  10 +
  drivers/mfd/Makefile         |   1 +
  drivers/mfd/rtsx_usb.c       | 760 +++++++++++++++++++++++++++++++++++++++++++
  include/linux/mfd/rtsx_usb.h | 628 +++++++++++++++++++++++++++++++++++
  4 files changed, 1399 insertions(+)

create mode 100644 drivers/mfd/rtsx_usb.c
create mode 100644 include/linux/mfd/rtsx_usb.h

Quoted 2 lines

Applied with Greg's Ack.

Thanks. But I have to modify some places in PATCH 2/3 and 3/3 according to Ulf's suggestion. I will resend v4 later but currently I don't plan to change the 1/3 part(for mfd) in it.

Would you wait for and re-apply the v4 submission or give any advice?

#4 lore raw

Re: [PATCH v3 1/3] mfd: Add realtek USB card reader driver

Quoted 22 lines · Roger
Quoted 21 lines · Lee Jones
Quoted 19 lines

From: Roger Tseng <[email protected]>

Realtek USB card reader provides a channel to transfer command or data to flash
memory cards. This driver exports host instances for mmc and memstick subsystems
and handles basic works.

---
  drivers/mfd/Kconfig          |  10 +
  drivers/mfd/Makefile         |   1 +
  drivers/mfd/rtsx_usb.c       | 760
+++++++++++++++++++++++++++++++++++++++++++
  include/linux/mfd/rtsx_usb.h | 628 +++++++++++++++++++++++++++++++++++
  4 files changed, 1399 insertions(+)

create mode 100644 drivers/mfd/rtsx_usb.c
create mode 100644 include/linux/mfd/rtsx_usb.h

Quoted 7 lines
Quoted 2 lines

Applied with Greg's Ack.

Thanks. But I have to modify some places in PATCH 2/3 and 3/3 according to Ulf's suggestion. I will resend v4 later but currently I don't plan to change the 1/3 part(for mfd) in it.

Would you wait for and re-apply the v4 submission or give any advice?

Just send a v4 of PATCH 2/3 and 3/3, that should be fine I think.

Kind regards
Ulf Hansson

#5 lore raw

Re: [PATCH v3 1/3] mfd: Add realtek USB card reader driver

In reply to Roger
Quoted 17 lines · Roger
Quoted 16 lines · Lee Jones
Quoted 15 lines

From: Roger Tseng <[email protected]>

Realtek USB card reader provides a channel to transfer command or data to flash memory cards. This driver exports host instances for mmc and memstick subsystems and handles basic works.

---
 drivers/mfd/Kconfig          |  10 +
 drivers/mfd/Makefile         |   1 +
 drivers/mfd/rtsx_usb.c       | 760 +++++++++++++++++++++++++++++++++++++++++++
 include/linux/mfd/rtsx_usb.h | 628 +++++++++++++++++++++++++++++++++++
 4 files changed, 1399 insertions(+)
 create mode 100644 drivers/mfd/rtsx_usb.c
 create mode 100644 include/linux/mfd/rtsx_usb.h
Quoted 7 lines
Quoted 2 lines

Applied with Greg's Ack.

Thanks. But I have to modify some places in PATCH 2/3 and 3/3 according to Ulf's suggestion. I will resend v4 later but currently I don't plan to change the 1/3 part(for mfd) in it.

Would you wait for and re-apply the v4 submission or give any advice?

Yes, no problem.

Signature · 8 lines
Lee Jones
Linaro STMicroelectronics Landing Team Lead
Linaro.org │ Open source software for ARM SoCs
Follow Linaro: Facebook | Twitter | Blog
_______________________________________________
devel mailing list
[email protected]
http://driverdev.linuxdriverproject.org/mailman/listinfo/driverdev-devel
#6 lore raw

PATCH v3 2/3 mmc: Add realtek USB sdmmc host driver

In reply to [email protected]

From: Roger Tseng <[email protected]>

Realtek USB SD/MMC host driver provides mmc host support based on the Realtek USB card reader MFD driver.

---
 drivers/mmc/host/Kconfig          |    7 +
 drivers/mmc/host/Makefile         |    1 +
 drivers/mmc/host/rtsx_usb_sdmmc.c | 1500 +++++++++++++++++++++++++++++++++++++
 3 files changed, 1508 insertions(+)
 create mode 100644 drivers/mmc/host/rtsx_usb_sdmmc.c
drivers/mmc/host/Kconfig +7 -0
index 7fc5099..16f9a23 100644
@@ -665,3 +665,10 @@ config MMC_REALTEK_PCI
 	help
 	  Say Y here to include driver code to support SD/MMC card interface
 	  of Realtek PCI-E card reader
+
+config MMC_REALTEK_USB
+	tristate "Realtek USB SD/MMC Card Interface Driver"
+	depends on MFD_RTSX_USB
+	help
+	  Say Y here to include driver code to support SD/MMC card interface
+	  of Realtek RTS5129/39 series card reader
drivers/mmc/host/Makefile +1 -0
index c41d0c3..9d8d765 100644
@@ -51,6 +51,7 @@ obj-$(CONFIG_MMC_USHC)		+= ushc.o
 obj-$(CONFIG_MMC_WMT)		+= wmt-sdmmc.o
 
 obj-$(CONFIG_MMC_REALTEK_PCI)	+= rtsx_pci_sdmmc.o
+obj-$(CONFIG_MMC_REALTEK_USB)	+= rtsx_usb_sdmmc.o
 
 obj-$(CONFIG_MMC_SDHCI_PLTFM)		+= sdhci-pltfm.o
 obj-$(CONFIG_MMC_SDHCI_CNS3XXX)		+= sdhci-cns3xxx.o
drivers/mmc/host/rtsx_usb_sdmmc.c new file +1500 -0

1,500 lines not on this page · raw message

Signature · 1 line
1.8.2
#7 lore raw

Re: [PATCH v3 2/3] mmc: Add realtek USB sdmmc host driver

Quoted 877 lines · On 6 February 2014 15:35, <[email protected]> wrote:

From: Roger Tseng <[email protected]>

Realtek USB SD/MMC host driver provides mmc host support based on the Realtek USB card reader MFD driver.

---
 drivers/mmc/host/Kconfig          |    7 +
 drivers/mmc/host/Makefile         |    1 +
 drivers/mmc/host/rtsx_usb_sdmmc.c | 1500 +++++++++++++++++++++++++++++++++++++
 3 files changed, 1508 insertions(+)
 create mode 100644 drivers/mmc/host/rtsx_usb_sdmmc.c
drivers/mmc/host/Kconfig +7 -0
index 7fc5099..16f9a23 100644
@@ -665,3 +665,10 @@ config MMC_REALTEK_PCI
        help
          Say Y here to include driver code to support SD/MMC card interface
          of Realtek PCI-E card reader
+
+config MMC_REALTEK_USB
+       tristate "Realtek USB SD/MMC Card Interface Driver"
+       depends on MFD_RTSX_USB
+       help
+         Say Y here to include driver code to support SD/MMC card interface
+         of Realtek RTS5129/39 series card reader
drivers/mmc/host/Makefile +1 -0
index c41d0c3..9d8d765 100644
@@ -51,6 +51,7 @@ obj-$(CONFIG_MMC_USHC)                += ushc.o
 obj-$(CONFIG_MMC_WMT)          += wmt-sdmmc.o
 
 obj-$(CONFIG_MMC_REALTEK_PCI)  += rtsx_pci_sdmmc.o
+obj-$(CONFIG_MMC_REALTEK_USB)  += rtsx_usb_sdmmc.o
 
 obj-$(CONFIG_MMC_SDHCI_PLTFM)          += sdhci-pltfm.o
 obj-$(CONFIG_MMC_SDHCI_CNS3XXX)                += sdhci-cns3xxx.o
drivers/mmc/host/rtsx_usb_sdmmc.c new file +831 -0
new file mode 100644
index 0000000..952d80b
@@ -0,0 +1,1500 @@
+/* Realtek USB SD/MMC Card Interface driver
+ *
+ * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author:
+ *   Roger Tseng <[email protected]>
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/usb.h>
+#include <linux/mmc/host.h>
+#include <linux/mmc/mmc.h>
+#include <linux/mmc/sd.h>
+#include <linux/mmc/sdio.h>
+#include <linux/mmc/card.h>
+#include <linux/scatterlist.h>
+#include <linux/pm_runtime.h>
+
+#include <linux/mfd/rtsx_usb.h>
+#include <asm/unaligned.h>
+
+#if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE)
+#include <linux/leds.h>
+#include <linux/workqueue.h>
+#define RTSX_USB_USE_LEDS_CLASS
+#endif
+
+struct rtsx_usb_sdmmc {
+       struct platform_device  *pdev;
+       struct rtsx_ucr *ucr;
+       struct mmc_host         *mmc;
+       struct mmc_request      *mrq;
+
+       struct mutex            host_mutex;
+
+       u8                      ssc_depth;
+       unsigned int            clock;
+       bool                    vpclk;
+       bool                    double_clk;
+       bool                    host_removal;
+       bool                    card_exist;
+       bool                    initial_mode;
+       bool                    ddr_mode;
+
+       unsigned char           power_mode;
+
+#if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE)
+       struct led_classdev     led;
+       char                    led_name[32];
+       struct work_struct      led_work;
+#endif
+};
+
+static inline struct device *sdmmc_dev(struct rtsx_usb_sdmmc *host)
+{
+       return &(host->pdev->dev);
+}
+
+static inline void sd_clear_error(struct rtsx_usb_sdmmc *host)
+{
+       struct rtsx_ucr *ucr = host->ucr;
+       rtsx_usb_ep0_write_register(ucr, CARD_STOP,
+                                 SD_STOP | SD_CLR_ERR,
+                                 SD_STOP | SD_CLR_ERR);
+
+       rtsx_usb_clear_dma_err(ucr);
+       rtsx_usb_clear_fsm_err(ucr);
+}
+
+#ifdef DEBUG
+static void sd_print_debug_regs(struct rtsx_usb_sdmmc *host)
+{
+       struct rtsx_ucr *ucr = host->ucr;
+       u8 val = 0;
+
+       rtsx_usb_ep0_read_register(ucr, SD_STAT1, &val);
+       dev_dbg(sdmmc_dev(host), "SD_STAT1: 0x%x\n", val);
+       rtsx_usb_ep0_read_register(ucr, SD_STAT2, &val);
+       dev_dbg(sdmmc_dev(host), "SD_STAT2: 0x%x\n", val);
+       rtsx_usb_ep0_read_register(ucr, SD_BUS_STAT, &val);
+       dev_dbg(sdmmc_dev(host), "SD_BUS_STAT: 0x%x\n", val);
+}
+#else
+#define sd_print_debug_regs(host)
+#endif /* DEBUG */
+
+static int sd_read_data(struct rtsx_usb_sdmmc *host, struct mmc_command *cmd,
+              u16 byte_cnt, u8 *buf, int buf_len, int timeout)
+{
+       struct rtsx_ucr *ucr = host->ucr;
+       int err;
+       u8 trans_mode;
+
+       if (!buf)
+               buf_len = 0;
+
+       rtsx_usb_init_cmd(ucr);
+       if (cmd != NULL) {
+               dev_dbg(sdmmc_dev(host), "%s: SD/MMC CMD%d\n", __func__
+                               , cmd->opcode);
+               if (cmd->opcode == MMC_SEND_TUNING_BLOCK)
+                       trans_mode = SD_TM_AUTO_TUNING;
+               else
+                       trans_mode = SD_TM_NORMAL_READ;
+
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               SD_CMD0, 0xFF, (u8)(cmd->opcode) | 0x40);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               SD_CMD1, 0xFF, (u8)(cmd->arg >> 24));
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               SD_CMD2, 0xFF, (u8)(cmd->arg >> 16));
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               SD_CMD3, 0xFF, (u8)(cmd->arg >> 8));
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               SD_CMD4, 0xFF, (u8)cmd->arg);
+       } else {
+               trans_mode = SD_TM_AUTO_READ_3;
+       }
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BYTE_CNT_L, 0xFF, (u8)byte_cnt);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BYTE_CNT_H,
+                       0xFF, (u8)(byte_cnt >> 8));
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BLOCK_CNT_L, 0xFF, 1);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BLOCK_CNT_H, 0xFF, 0);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CFG2, 0xFF,
+                       SD_CALCULATE_CRC7 | SD_CHECK_CRC16 |
+                       SD_NO_WAIT_BUSY_END | SD_CHECK_CRC7 | SD_RSP_LEN_6);
+       if (trans_mode != SD_TM_AUTO_TUNING)
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               CARD_DATA_SOURCE, 0x01, PINGPONG_BUFFER);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_TRANSFER,
+                       0xFF, trans_mode | SD_TRANSFER_START);
+       rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, SD_TRANSFER,
+                       SD_TRANSFER_END, SD_TRANSFER_END);
+
+       if (cmd != NULL) {
+               rtsx_usb_add_cmd(ucr, READ_REG_CMD, SD_CMD1, 0, 0);
+               rtsx_usb_add_cmd(ucr, READ_REG_CMD, SD_CMD2, 0, 0);
+               rtsx_usb_add_cmd(ucr, READ_REG_CMD, SD_CMD3, 0, 0);
+               rtsx_usb_add_cmd(ucr, READ_REG_CMD, SD_CMD4, 0, 0);
+       }
+
+       err = rtsx_usb_send_cmd(ucr, MODE_CR, timeout);
+       if (err) {
+               dev_dbg(sdmmc_dev(host),
+                       "rtsx_usb_send_cmd failed (err = %d)\n", err);
+               return err;
+       }
+
+       err = rtsx_usb_get_rsp(ucr, !cmd ? 1 : 5, timeout);
+       if (err || (ucr->rsp_buf[0] & SD_TRANSFER_ERR)) {
+               sd_print_debug_regs(host);
+
+               if (!err) {
+                       dev_dbg(sdmmc_dev(host),
+                               "Transfer failed (SD_TRANSFER = %02x)\n",
+                               ucr->rsp_buf[0]);
+                       err = -EIO;
+               } else {
+                       dev_dbg(sdmmc_dev(host),
+                               "rtsx_usb_get_rsp failed (err = %d)\n", err);
+               }
+
+               return err;
+       }
+
+       if (cmd != NULL) {
+               cmd->resp[0] = get_unaligned_be32(ucr->rsp_buf + 1);
+               dev_dbg(sdmmc_dev(host), "cmd->resp[0] = 0x%08x\n",
+                               cmd->resp[0]);
+       }
+
+       if (buf && buf_len) {
+               /* 2-byte aligned part */
+               err = rtsx_usb_read_ppbuf(ucr, buf, byte_cnt - (byte_cnt % 2));
+               if (err) {
+                       dev_dbg(sdmmc_dev(host),
+                               "rtsx_usb_read_ppbuf failed (err = %d)\n", err);
+                       return err;
+               }
+
+               /* unaligned byte */
+               if (byte_cnt % 2)
+                       return rtsx_usb_read_register(ucr,
+                                       PPBUF_BASE2 + byte_cnt,
+                                       buf + byte_cnt - 1);
+       }
+
+       return 0;
+}
+
+static int sd_write_data(struct rtsx_usb_sdmmc *host, struct mmc_command *cmd,
+               u16 byte_cnt, u8 *buf, int buf_len, int timeout)
+{
+       struct rtsx_ucr *ucr = host->ucr;
+       int err;
+       u8 trans_mode;
+
+       if (!buf)
+               buf_len = 0;
+
+       if (buf && buf_len) {
+               err = rtsx_usb_write_ppbuf(ucr, buf, buf_len);
+               if (err) {
+                       dev_dbg(sdmmc_dev(host),
+                               "rtsx_usb_write_ppbuf failed (err = %d)\n",
+                               err);
+                       return err;
+               }
+       }
+
+       trans_mode = (cmd != NULL) ? SD_TM_AUTO_WRITE_2 : SD_TM_AUTO_WRITE_3;
+       rtsx_usb_init_cmd(ucr);
+
+       if (cmd != NULL) {
+               dev_dbg(sdmmc_dev(host), "%s: SD/MMC CMD%d\n", __func__,
+                               cmd->opcode);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               SD_CMD0, 0xFF, (u8)(cmd->opcode) | 0x40);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               SD_CMD1, 0xFF, (u8)(cmd->arg >> 24));
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               SD_CMD2, 0xFF, (u8)(cmd->arg >> 16));
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               SD_CMD3, 0xFF, (u8)(cmd->arg >> 8));
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               SD_CMD4, 0xFF, (u8)cmd->arg);
+       }
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BYTE_CNT_L, 0xFF, (u8)byte_cnt);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BYTE_CNT_H,
+                       0xFF, (u8)(byte_cnt >> 8));
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BLOCK_CNT_L, 0xFF, 1);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BLOCK_CNT_H, 0xFF, 0);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CFG2, 0xFF,
+               SD_CALCULATE_CRC7 | SD_CHECK_CRC16 |
+               SD_NO_WAIT_BUSY_END | SD_CHECK_CRC7 | SD_RSP_LEN_6);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                       CARD_DATA_SOURCE, 0x01, PINGPONG_BUFFER);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_TRANSFER, 0xFF,
+                       trans_mode | SD_TRANSFER_START);
+       rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, SD_TRANSFER,
+                       SD_TRANSFER_END, SD_TRANSFER_END);
+
+       if (cmd != NULL) {
+               rtsx_usb_add_cmd(ucr, READ_REG_CMD, SD_CMD1, 0, 0);
+               rtsx_usb_add_cmd(ucr, READ_REG_CMD, SD_CMD2, 0, 0);
+               rtsx_usb_add_cmd(ucr, READ_REG_CMD, SD_CMD3, 0, 0);
+               rtsx_usb_add_cmd(ucr, READ_REG_CMD, SD_CMD4, 0, 0);
+       }
+
+       err = rtsx_usb_send_cmd(ucr, MODE_CR, timeout);
+       if (err) {
+               dev_dbg(sdmmc_dev(host),
+                       "rtsx_usb_send_cmd failed (err = %d)\n", err);
+               return err;
+       }
+
+       err = rtsx_usb_get_rsp(ucr, !cmd ? 1 : 5, timeout);
+       if (err) {
+               sd_print_debug_regs(host);
+               dev_dbg(sdmmc_dev(host),
+                       "rtsx_usb_get_rsp failed (err = %d)\n", err);
+               return err;
+       }
+
+       if (cmd != NULL) {
+               cmd->resp[0] = get_unaligned_be32(ucr->rsp_buf + 1);
+               dev_dbg(sdmmc_dev(host), "cmd->resp[0] = 0x%08x\n",
+                               cmd->resp[0]);
+       }
+
+       return 0;
+}
+
+static void sd_send_cmd_get_rsp(struct rtsx_usb_sdmmc *host,
+               struct mmc_command *cmd)
+{
+       struct rtsx_ucr *ucr = host->ucr;
+       u8 cmd_idx = (u8)cmd->opcode;
+       u32 arg = cmd->arg;
+       int err = 0;
+       int timeout = 100;
+       int i;
+       u8 *ptr;
+       int stat_idx = 0;
+       int len = 2;
+       u8 rsp_type;
+
+       dev_dbg(sdmmc_dev(host), "%s: SD/MMC CMD %d, arg = 0x%08x\n",
+                       __func__, cmd_idx, arg);
+
+       /* Response type:
+        * R0
+        * R1, R5, R6, R7
+        * R1b
+        * R2
+        * R3, R4
+        */
+       switch (mmc_resp_type(cmd)) {
+       case MMC_RSP_NONE:
+               rsp_type = SD_RSP_TYPE_R0;
+               break;
+       case MMC_RSP_R1:
+               rsp_type = SD_RSP_TYPE_R1;
+               break;
+       case MMC_RSP_R1B:
+               rsp_type = SD_RSP_TYPE_R1b;
+               break;
+       case MMC_RSP_R2:
+               rsp_type = SD_RSP_TYPE_R2;
+               break;
+       case MMC_RSP_R3:
+               rsp_type = SD_RSP_TYPE_R3;
+               break;
+       default:
+               dev_dbg(sdmmc_dev(host), "cmd->flag is not valid\n");
+               err = -EINVAL;
+               goto out;
+       }
+
+       if (rsp_type == SD_RSP_TYPE_R1b)
+               timeout = 3000;
+
+       if (cmd->opcode == SD_SWITCH_VOLTAGE) {
+               err = rtsx_usb_write_register(ucr, SD_BUS_STAT,
+                               SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP,
+                               SD_CLK_TOGGLE_EN);
+               if (err)
+                       goto out;
+       }
+
+       rtsx_usb_init_cmd(ucr);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CMD0, 0xFF, 0x40 | cmd_idx);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CMD1, 0xFF, (u8)(arg >> 24));
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CMD2, 0xFF, (u8)(arg >> 16));
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CMD3, 0xFF, (u8)(arg >> 8));
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CMD4, 0xFF, (u8)arg);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CFG2, 0xFF, rsp_type);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
+                       0x01, PINGPONG_BUFFER);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_TRANSFER,
+                       0xFF, SD_TM_CMD_RSP | SD_TRANSFER_START);
+       rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, SD_TRANSFER,
+                    SD_TRANSFER_END | SD_STAT_IDLE,
+                    SD_TRANSFER_END | SD_STAT_IDLE);
+
+       if (rsp_type == SD_RSP_TYPE_R2) {
+               /* Read data from ping-pong buffer */
+               for (i = PPBUF_BASE2; i < PPBUF_BASE2 + 16; i++)
+                       rtsx_usb_add_cmd(ucr, READ_REG_CMD, (u16)i, 0, 0);
+               stat_idx = 16;
+       } else if (rsp_type != SD_RSP_TYPE_R0) {
+               /* Read data from SD_CMDx registers */
+               for (i = SD_CMD0; i <= SD_CMD4; i++)
+                       rtsx_usb_add_cmd(ucr, READ_REG_CMD, (u16)i, 0, 0);
+               stat_idx = 5;
+       }
+       len += stat_idx;
+
+       rtsx_usb_add_cmd(ucr, READ_REG_CMD, SD_STAT1, 0, 0);
+
+       err = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
+       if (err) {
+               dev_dbg(sdmmc_dev(host),
+                       "rtsx_usb_send_cmd error (err = %d)\n", err);
+               goto out;
+       }
+
+       err = rtsx_usb_get_rsp(ucr, len, timeout);
+       if (err || (ucr->rsp_buf[0] & SD_TRANSFER_ERR)) {
+               sd_print_debug_regs(host);
+               sd_clear_error(host);
+
+               if (!err) {
+                       dev_dbg(sdmmc_dev(host),
+                               "Transfer failed (SD_TRANSFER = %02x)\n",
+                                       ucr->rsp_buf[0]);
+                       err = -EIO;
+               } else {
+                       dev_dbg(sdmmc_dev(host),
+                               "rtsx_usb_get_rsp failed (err = %d)\n", err);
+               }
+
+               goto out;
+       }
+
+       if (rsp_type == SD_RSP_TYPE_R0) {
+               err = 0;
+               goto out;
+       }
+
+       /* Skip result of CHECK_REG_CMD */
+       ptr = ucr->rsp_buf + 1;
+
+       /* Check (Start,Transmission) bit of Response */
+       if ((ptr[0] & 0xC0) != 0) {
+               err = -EILSEQ;
+               dev_dbg(sdmmc_dev(host), "Invalid response bit\n");
+               goto out;
+       }
+
+       /* Check CRC7 */
+       if (!(rsp_type & SD_NO_CHECK_CRC7)) {
+               if (ptr[stat_idx] & SD_CRC7_ERR) {
+                       err = -EILSEQ;
+                       dev_dbg(sdmmc_dev(host), "CRC7 error\n");
+                       goto out;
+               }
+       }
+
+       if (rsp_type == SD_RSP_TYPE_R2) {
+               for (i = 0; i < 4; i++) {
+                       cmd->resp[i] = get_unaligned_be32(ptr + 1 + i * 4);
+                       dev_dbg(sdmmc_dev(host), "cmd->resp[%d] = 0x%08x\n",
+                                       i, cmd->resp[i]);
+               }
+       } else {
+               cmd->resp[0] = get_unaligned_be32(ptr + 1);
+               dev_dbg(sdmmc_dev(host), "cmd->resp[0] = 0x%08x\n",
+                               cmd->resp[0]);
+       }
+
+out:
+       cmd->error = err;
+}
+
+static int sd_rw_multi(struct rtsx_usb_sdmmc *host, struct mmc_request *mrq)
+{
+       struct rtsx_ucr *ucr = host->ucr;
+       struct mmc_data *data = mrq->data;
+       int read = (data->flags & MMC_DATA_READ) ? 1 : 0;
+       u8 cfg2, trans_mode;
+       int err;
+       u8 flag;
+       size_t data_len = data->blksz * data->blocks;
+       unsigned int pipe;
+
+       if (read) {
+               dev_dbg(sdmmc_dev(host), "%s: read %zu bytes\n",
+                               __func__, data_len);
+               cfg2 = SD_CALCULATE_CRC7 | SD_CHECK_CRC16 |
+                       SD_NO_WAIT_BUSY_END | SD_CHECK_CRC7 | SD_RSP_LEN_0;
+               trans_mode = SD_TM_AUTO_READ_3;
+       } else {
+               dev_dbg(sdmmc_dev(host), "%s: write %zu bytes\n",
+                               __func__, data_len);
+               cfg2 = SD_NO_CALCULATE_CRC7 | SD_CHECK_CRC16 |
+                       SD_NO_WAIT_BUSY_END | SD_NO_CHECK_CRC7 | SD_RSP_LEN_0;
+               trans_mode = SD_TM_AUTO_WRITE_3;
+       }
+
+       rtsx_usb_init_cmd(ucr);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BYTE_CNT_L, 0xFF, 0x00);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BYTE_CNT_H, 0xFF, 0x02);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BLOCK_CNT_L,
+                       0xFF, (u8)data->blocks);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BLOCK_CNT_H,
+                       0xFF, (u8)(data->blocks >> 8));
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
+                       0x01, RING_BUFFER);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC3,
+                       0xFF, (u8)(data_len >> 24));
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC2,
+                       0xFF, (u8)(data_len >> 16));
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC1,
+                       0xFF, (u8)(data_len >> 8));
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC0,
+                       0xFF, (u8)data_len);
+       if (read) {
+               flag = MODE_CDIR;
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_CTL,
+                               0x03 | DMA_PACK_SIZE_MASK,
+                               DMA_DIR_FROM_CARD | DMA_EN | DMA_512);
+       } else {
+               flag = MODE_CDOR;
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_CTL,
+                               0x03 | DMA_PACK_SIZE_MASK,
+                               DMA_DIR_TO_CARD | DMA_EN | DMA_512);
+       }
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CFG2, 0xFF, cfg2);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_TRANSFER, 0xFF,
+                       trans_mode | SD_TRANSFER_START);
+       rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, SD_TRANSFER,
+                       SD_TRANSFER_END, SD_TRANSFER_END);
+
+       err = rtsx_usb_send_cmd(ucr, flag, 100);
+       if (err)
+               return err;
+
+       if (read)
+               pipe = usb_rcvbulkpipe(ucr->pusb_dev, EP_BULK_IN);
+       else
+               pipe = usb_sndbulkpipe(ucr->pusb_dev, EP_BULK_OUT);
+
+       err = rtsx_usb_transfer_data(ucr, pipe, data->sg, data_len,
+                       data->sg_len,  NULL, 10000);
+       if (err) {
+               dev_dbg(sdmmc_dev(host), "rtsx_usb_transfer_data error %d\n"
+                               , err);
+               sd_clear_error(host);
+               return err;
+       }
+
+       return rtsx_usb_get_rsp(ucr, 1, 2000);
+}
+
+static inline void sd_enable_initial_mode(struct rtsx_usb_sdmmc *host)
+{
+       rtsx_usb_write_register(host->ucr, SD_CFG1,
+                       SD_CLK_DIVIDE_MASK, SD_CLK_DIVIDE_128);
+}
+
+static inline void sd_disable_initial_mode(struct rtsx_usb_sdmmc *host)
+{
+       rtsx_usb_write_register(host->ucr, SD_CFG1,
+                       SD_CLK_DIVIDE_MASK, SD_CLK_DIVIDE_0);
+}
+
+static void sd_normal_rw(struct rtsx_usb_sdmmc *host,
+               struct mmc_request *mrq)
+{
+       struct mmc_command *cmd = mrq->cmd;
+       struct mmc_data *data = mrq->data;
+       u8 *buf;
+
+       buf = kzalloc(data->blksz, GFP_NOIO);
+       if (!buf) {
+               cmd->error = -ENOMEM;
+               return;
+       }
+
+       if (data->flags & MMC_DATA_READ) {
+               if (host->initial_mode)
+                       sd_disable_initial_mode(host);
+
+               cmd->error = sd_read_data(host, cmd, (u16)data->blksz, buf,
+                               data->blksz, 200);
+
+               if (host->initial_mode)
+                       sd_enable_initial_mode(host);
+
+               sg_copy_from_buffer(data->sg, data->sg_len, buf, data->blksz);
+       } else {
+               sg_copy_to_buffer(data->sg, data->sg_len, buf, data->blksz);
+
+               cmd->error = sd_write_data(host, cmd, (u16)data->blksz, buf,
+                               data->blksz, 200);
+       }
+
+       kfree(buf);
+}
+
+static int sd_change_phase(struct rtsx_usb_sdmmc *host, u8 sample_point, int tx)
+{
+       struct rtsx_ucr *ucr = host->ucr;
+       int err;
+
+       dev_dbg(sdmmc_dev(host), "%s: %s sample_point = %d\n",
+                       __func__, tx ? "TX" : "RX", sample_point);
+
+       rtsx_usb_init_cmd(ucr);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CLK_DIV, CLK_CHANGE, CLK_CHANGE);
+
+       if (tx)
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_VPCLK0_CTL,
+                               0x0F, sample_point);
+       else
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_VPCLK1_CTL,
+                               0x0F, sample_point);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_VPCLK0_CTL, PHASE_NOT_RESET, 0);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_VPCLK0_CTL,
+                       PHASE_NOT_RESET, PHASE_NOT_RESET);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CLK_DIV, CLK_CHANGE, 0);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CFG1, SD_ASYNC_FIFO_RST, 0);
+
+       err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
+       if (err)
+               return err;
+
+       return 0;
+}
+
+static inline u32 get_phase_point(u32 phase_map, unsigned int idx)
+{
+       idx &= MAX_PHASE;
+       return phase_map & (1 << idx);
+}
+
+static int get_phase_len(u32 phase_map, unsigned int idx)
+{
+       int i;
+
+       for (i = 0; i < MAX_PHASE + 1; i++) {
+               if (get_phase_point(phase_map, idx + i) == 0)
+                       return i;
+       }
+       return MAX_PHASE + 1;
+}
+
+static u8 sd_search_final_phase(struct rtsx_usb_sdmmc *host, u32 phase_map)
+{
+       int start = 0, len = 0;
+       int start_final = 0, len_final = 0;
+       u8 final_phase = 0xFF;
+
+       if (phase_map == 0) {
+               dev_dbg(sdmmc_dev(host), "Phase: [map:%x]\n", phase_map);
+               return final_phase;
+       }
+
+       while (start < MAX_PHASE + 1) {
+               len = get_phase_len(phase_map, start);
+               if (len_final < len) {
+                       start_final = start;
+                       len_final = len;
+               }
+               start += len ? len : 1;
+       }
+
+       final_phase = (start_final + len_final / 2) & MAX_PHASE;
+       dev_dbg(sdmmc_dev(host), "Phase: [map:%x] [maxlen:%d] [final:%d]\n",
+               phase_map, len_final, final_phase);
+
+       return final_phase;
+}
+
+static void sd_wait_data_idle(struct rtsx_usb_sdmmc *host)
+{
+       int err, i;
+       u8 val = 0;
+
+       for (i = 0; i < 100; i++) {
+               err = rtsx_usb_ep0_read_register(host->ucr,
+                               SD_DATA_STATE, &val);
+               if (val & SD_DATA_IDLE)
+                       return;
+
+               usleep_range(100, 1000);
+       }
+}
+
+static int sd_tuning_rx_cmd(struct rtsx_usb_sdmmc *host,
+               u8 opcode, u8 sample_point)
+{
+       int err;
+       struct mmc_command cmd = {0};
+
+       err = sd_change_phase(host, sample_point, 0);
+       if (err)
+               return err;
+
+       cmd.opcode = MMC_SEND_TUNING_BLOCK;
+       err = sd_read_data(host, &cmd, 0x40, NULL, 0, 100);
+       if (err) {
+               /* Wait till SD DATA IDLE */
+               sd_wait_data_idle(host);
+               sd_clear_error(host);
+               return err;
+       }
+
+       return 0;
+}
+
+static void sd_tuning_phase(struct rtsx_usb_sdmmc *host,
+               u8 opcode, u16 *phase_map)
+{
+       int err, i;
+       u16 raw_phase_map = 0;
+
+       for (i = MAX_PHASE; i >= 0; i--) {
+               err = sd_tuning_rx_cmd(host, opcode, (u8)i);
+               if (!err)
+                       raw_phase_map |= 1 << i;
+       }
+
+       if (phase_map)
+               *phase_map = raw_phase_map;
+}
+
+static int sd_tuning_rx(struct rtsx_usb_sdmmc *host, u8 opcode)
+{
+       int err, i;
+       u16 raw_phase_map[RX_TUNING_CNT] = {0}, phase_map;
+       u8 final_phase;
+
+       /* setting fixed default TX phase */
+       err = sd_change_phase(host, 0x01, 1);
+       if (err) {
+               dev_dbg(sdmmc_dev(host), "TX phase setting failed\n");
+               return err;
+       }
+
+       /* tuning RX phase */
+       for (i = 0; i < RX_TUNING_CNT; i++) {
+               sd_tuning_phase(host, opcode, &(raw_phase_map[i]));
+
+               if (raw_phase_map[i] == 0)
+                       break;
+       }
+
+       phase_map = 0xFFFF;
+       for (i = 0; i < RX_TUNING_CNT; i++) {
+               dev_dbg(sdmmc_dev(host), "RX raw_phase_map[%d] = 0x%04x\n",
+                               i, raw_phase_map[i]);
+               phase_map &= raw_phase_map[i];
+       }
+       dev_dbg(sdmmc_dev(host), "RX phase_map = 0x%04x\n", phase_map);
+
+       if (phase_map) {
+               final_phase = sd_search_final_phase(host, phase_map);
+               if (final_phase == 0xFF)
+                       return -EINVAL;
+
+               err = sd_change_phase(host, final_phase, 0);
+               if (err)
+                       return err;
+       } else {
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+static int sdmmc_get_ro(struct mmc_host *mmc)
+{
+       struct rtsx_usb_sdmmc *host = mmc_priv(mmc);
+       struct rtsx_ucr *ucr = host->ucr;
+       int err;
+       u16 val;
+
+       if (host->host_removal)
+               return -ENOMEDIUM;
+
+       mutex_lock(&ucr->dev_mutex);
+
+       /* Check SD card detect */
+       err = rtsx_usb_get_card_status(ucr, &val);
+
+       mutex_unlock(&ucr->dev_mutex);
+
+
+       /* Treat failed detection as non-ro */
+       if (err)
+               return 0;
+
+       if (val & SD_WP)
+               return 1;
+
+       return 0;
+}
+
+static int sdmmc_get_cd(struct mmc_host *mmc)
+{
+       struct rtsx_usb_sdmmc *host = mmc_priv(mmc);
+       struct rtsx_ucr *ucr = host->ucr;
+       int err;
+       u16 val;
+
+       if (host->host_removal)
+               return -ENOMEDIUM;
+
+       mutex_lock(&ucr->dev_mutex);
+
+       /* Check SD card detect */
+       err = rtsx_usb_get_card_status(ucr, &val);
+
+       mutex_unlock(&ucr->dev_mutex);
+
+       /* Treat failed detection as non-exist */
+       if (err)
+               goto no_card;
+
+       if (val & SD_CD) {
+               host->card_exist = true;
+               return 1;
+       }
+
+no_card:
+       host->card_exist = false;
+       return 0;
+}
+
+static void sdmmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
+{
+       struct rtsx_usb_sdmmc *host = mmc_priv(mmc);
+       struct rtsx_ucr *ucr = host->ucr;
+       struct mmc_command *cmd = mrq->cmd;
+       struct mmc_data *data = mrq->data;
+       unsigned int data_size = 0;
+
+       dev_dbg(sdmmc_dev(host), "%s\n", __func__);
+
+       if (host->host_removal) {
+               cmd->error = -ENOMEDIUM;
+               goto finish;
+       }
+
+       if ((!host->card_exist)) {
+               cmd->error = -ENOMEDIUM;
+               goto finish_detect_card;
+       }
+
+       /*

drivers/mmc/host/rtsx_usb_sdmmc.c line 841

Quoted 10 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +10 -0
+        * Reject SDIO CMDs to speed up card identification
+        * since unsupported
+        */
+       if (cmd->opcode == SD_IO_SEND_OP_COND ||
+           cmd->opcode == SD_IO_RW_DIRECT ||
+           cmd->opcode == SD_IO_RW_EXTENDED) {
+               cmd->error = -EINVAL;
+               goto finish;
+       }
+

An option to above code would be to add a new mmc cap; like "MMC_CAP_NO_SDIO". The mmc core could then just skip SDIO parts, during the card detection sequence.

I guess there are other host drivers that might find this useful as well.

Quoted 195 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +195 -0
+       mutex_lock(&ucr->dev_mutex);
+
+       mutex_lock(&host->host_mutex);
+       host->mrq = mrq;
+       mutex_unlock(&host->host_mutex);
+
+       if (mrq->data)
+               data_size = data->blocks * data->blksz;
+
+       if (!data_size) {
+               sd_send_cmd_get_rsp(host, cmd);
+       } else if ((!(data_size % 512) && cmd->opcode != MMC_SEND_EXT_CSD) ||
+                  mmc_op_multi(cmd->opcode)) {
+               sd_send_cmd_get_rsp(host, cmd);
+
+               if (!cmd->error) {
+                       sd_rw_multi(host, mrq);
+
+                       if (mmc_op_multi(cmd->opcode) && mrq->stop) {
+                               sd_send_cmd_get_rsp(host, mrq->stop);
+                               rtsx_usb_write_register(ucr, MC_FIFO_CTL,
+                                               FIFO_FLUSH, FIFO_FLUSH);
+                       }
+               }
+       } else {
+               sd_normal_rw(host, mrq);
+       }
+
+       if (mrq->data) {
+               if (cmd->error || data->error)
+                       data->bytes_xfered = 0;
+               else
+                       data->bytes_xfered = data->blocks * data->blksz;
+       }
+
+       mutex_unlock(&ucr->dev_mutex);
+
+finish_detect_card:
+       if (cmd->error) {
+               /*
+                * detect card when fail to update card existence state and
+                * speed up card removal when retry
+                */
+               sdmmc_get_cd(mmc);
+               dev_dbg(sdmmc_dev(host), "cmd->error = %d\n", cmd->error);
+       }
+
+finish:
+       mutex_lock(&host->host_mutex);
+       host->mrq = NULL;
+       mutex_unlock(&host->host_mutex);
+
+       mmc_request_done(mmc, mrq);
+}
+
+static int sd_set_bus_width(struct rtsx_usb_sdmmc *host,
+               unsigned char bus_width)
+{
+       int err = 0;
+       u8 width[] = {
+               [MMC_BUS_WIDTH_1] = SD_BUS_WIDTH_1BIT,
+               [MMC_BUS_WIDTH_4] = SD_BUS_WIDTH_4BIT,
+               [MMC_BUS_WIDTH_8] = SD_BUS_WIDTH_8BIT,
+       };
+
+       if (bus_width <= MMC_BUS_WIDTH_8)
+               err = rtsx_usb_write_register(host->ucr, SD_CFG1,
+                               0x03, width[bus_width]);
+
+       return err;
+}
+
+static int sd_pull_ctl_disable_lqfp48(struct rtsx_ucr *ucr)
+{
+       rtsx_usb_init_cmd(ucr);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x55);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x55);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0xA5);
+
+       return rtsx_usb_send_cmd(ucr, MODE_C, 100);
+}
+
+static int sd_pull_ctl_disable_qfn24(struct rtsx_ucr *ucr)
+{
+       rtsx_usb_init_cmd(ucr);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x65);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x56);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0x59);
+
+       return rtsx_usb_send_cmd(ucr, MODE_C, 100);
+}
+
+static int sd_pull_ctl_enable_lqfp48(struct rtsx_ucr *ucr)
+{
+       rtsx_usb_init_cmd(ucr);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0xAA);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0xAA);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0xA9);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x55);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0xA5);
+
+       return rtsx_usb_send_cmd(ucr, MODE_C, 100);
+}
+
+static int sd_pull_ctl_enable_qfn24(struct rtsx_ucr *ucr)
+{
+       rtsx_usb_init_cmd(ucr);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0xA5);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x9A);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0xA5);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x9A);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x65);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0x5A);
+
+       return rtsx_usb_send_cmd(ucr, MODE_C, 100);
+}
+
+static int sd_power_on(struct rtsx_usb_sdmmc *host)
+{
+       struct rtsx_ucr *ucr = host->ucr;
+       int err;
+
+       dev_dbg(sdmmc_dev(host), "%s\n", __func__);
+       rtsx_usb_init_cmd(ucr);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_SELECT, 0x07, SD_MOD_SEL);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_SHARE_MODE,
+                       CARD_SHARE_MASK, CARD_SHARE_SD);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_EN,
+                       SD_CLK_EN, SD_CLK_EN);
+       err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
+       if (err)
+               return err;
+
+       if (CHECK_PKG(ucr, LQFP48))
+               err = sd_pull_ctl_enable_lqfp48(ucr);
+       else
+               err = sd_pull_ctl_enable_qfn24(ucr);
+       if (err)
+               return err;
+
+       err = rtsx_usb_write_register(ucr, CARD_PWR_CTL,
+                       POWER_MASK, PARTIAL_POWER_ON);
+       if (err)
+               return err;
+
+       usleep_range(800, 1000);
+
+       rtsx_usb_init_cmd(ucr);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
+                       POWER_MASK|LDO3318_PWR_MASK, POWER_ON|LDO_ON);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_OE,
+                       SD_OUTPUT_EN, SD_OUTPUT_EN);
+
+       return rtsx_usb_send_cmd(ucr, MODE_C, 100);
+}
+
+static int sd_power_off(struct rtsx_usb_sdmmc *host)
+{
+       struct rtsx_ucr *ucr = host->ucr;
+       int err;
+
+       dev_dbg(sdmmc_dev(host), "%s\n", __func__);
+       rtsx_usb_init_cmd(ucr);
+
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_EN, SD_CLK_EN, 0);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_OE, SD_OUTPUT_EN, 0);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
+                       POWER_MASK, POWER_OFF);
+       rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
+                       POWER_MASK|LDO3318_PWR_MASK, POWER_OFF|LDO_SUSPEND);
+
+       err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
+       if (err)
+               return err;
+
+       if (CHECK_PKG(ucr, LQFP48))
+                       return sd_pull_ctl_disable_lqfp48(ucr);
+       return sd_pull_ctl_disable_qfn24(ucr);
+}
+
+static int sd_set_power_mode(struct rtsx_usb_sdmmc *host,
+               unsigned char power_mode)
+{
+       int err;

drivers/mmc/host/rtsx_usb_sdmmc.c line 1046

Quoted 10 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +10 -0
+
+       if (power_mode != MMC_POWER_OFF)
+               power_mode = MMC_POWER_ON;
+
+       if (power_mode == host->power_mode)
+               return 0;
+
+       if (power_mode == MMC_POWER_OFF) {
+               err = sd_power_off(host);
+#ifdef CONFIG_PM_RUNTIME

There are stubs for pm_runtime* functions, thus the ifdefs can be removed. Please go though the complete patch and remove all instances.

drivers/mmc/host/rtsx_usb_sdmmc.c line 1047

Quoted 1 line
drivers/mmc/host/rtsx_usb_sdmmc.c new file +1 -0
+               pm_runtime_put(sdmmc_dev(host));

I don't know so much about USB mmc hosts hardware, but I just wanted to find out if I have understood this correct.

You can't do fine grained power management of the USB parent device, since it needs to be runtime resumed to be able keep the power the card? Once it becomes runtime suspended, the power to the card will thus also be dropped?

Quoted 233 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +233 -0
+#endif
+       } else {
+#ifdef CONFIG_PM_RUNTIME
+               pm_runtime_get_sync(sdmmc_dev(host));
+#endif
+               err = sd_power_on(host);
+       }
+
+       if (!err)
+               host->power_mode = power_mode;
+
+       return err;
+}
+
+static int sd_set_timing(struct rtsx_usb_sdmmc *host,
+               unsigned char timing, bool *ddr_mode)
+{
+       struct rtsx_ucr *ucr = host->ucr;
+       int err;
+
+       *ddr_mode = false;
+
+       rtsx_usb_init_cmd(ucr);
+
+       switch (timing) {
+       case MMC_TIMING_UHS_SDR104:
+       case MMC_TIMING_UHS_SDR50:
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CFG1,
+                               0x0C | SD_ASYNC_FIFO_RST,
+                               SD_30_MODE | SD_ASYNC_FIFO_RST);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_SOURCE, 0xFF,
+                               CRC_VAR_CLK0 | SD30_FIX_CLK | SAMPLE_VAR_CLK1);
+               break;
+
+       case MMC_TIMING_UHS_DDR50:
+               *ddr_mode = true;
+
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CFG1,
+                               0x0C | SD_ASYNC_FIFO_RST,
+                               SD_DDR_MODE | SD_ASYNC_FIFO_RST);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_SOURCE, 0xFF,
+                               CRC_VAR_CLK0 | SD30_FIX_CLK | SAMPLE_VAR_CLK1);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_PUSH_POINT_CTL,
+                               DDR_VAR_TX_CMD_DAT, DDR_VAR_TX_CMD_DAT);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_SAMPLE_POINT_CTL,
+                               DDR_VAR_RX_DAT | DDR_VAR_RX_CMD,
+                               DDR_VAR_RX_DAT | DDR_VAR_RX_CMD);
+               break;
+
+       case MMC_TIMING_MMC_HS:
+       case MMC_TIMING_SD_HS:
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_CFG1,
+                               0x0C, SD_20_MODE);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_SOURCE, 0xFF,
+                               CRC_FIX_CLK | SD30_VAR_CLK0 | SAMPLE_VAR_CLK1);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_PUSH_POINT_CTL,
+                               SD20_TX_SEL_MASK, SD20_TX_14_AHEAD);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_SAMPLE_POINT_CTL,
+                               SD20_RX_SEL_MASK, SD20_RX_14_DELAY);
+               break;
+
+       default:
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               SD_CFG1, 0x0C, SD_20_MODE);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_SOURCE, 0xFF,
+                               CRC_FIX_CLK | SD30_VAR_CLK0 | SAMPLE_VAR_CLK1);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+                               SD_PUSH_POINT_CTL, 0xFF, 0);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_SAMPLE_POINT_CTL,
+                               SD20_RX_SEL_MASK, SD20_RX_POS_EDGE);
+               break;
+       }
+
+       err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
+
+       return err;
+}
+
+static void sdmmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+       struct rtsx_usb_sdmmc *host = mmc_priv(mmc);
+       struct rtsx_ucr *ucr = host->ucr;
+
+       dev_dbg(sdmmc_dev(host), "%s\n", __func__);
+       mutex_lock(&ucr->dev_mutex);
+
+       if (rtsx_usb_card_exclusive_check(ucr, RTSX_USB_SD_CARD)) {
+               mutex_unlock(&ucr->dev_mutex);
+               return;
+       }
+
+       sd_set_power_mode(host, ios->power_mode);
+       sd_set_bus_width(host, ios->bus_width);
+       sd_set_timing(host, ios->timing, &host->ddr_mode);
+
+       host->vpclk = false;
+       host->double_clk = true;
+
+       switch (ios->timing) {
+       case MMC_TIMING_UHS_SDR104:
+       case MMC_TIMING_UHS_SDR50:
+               host->ssc_depth = SSC_DEPTH_2M;
+               host->vpclk = true;
+               host->double_clk = false;
+               break;
+       case MMC_TIMING_UHS_DDR50:
+       case MMC_TIMING_UHS_SDR25:
+               host->ssc_depth = SSC_DEPTH_1M;
+               break;
+       default:
+               host->ssc_depth = SSC_DEPTH_512K;
+               break;
+       }
+
+       host->initial_mode = (ios->clock <= 1000000) ? true : false;
+       host->clock = ios->clock;
+
+       rtsx_usb_switch_clock(host->ucr, host->clock, host->ssc_depth,
+                       host->initial_mode, host->double_clk, host->vpclk);
+
+       mutex_unlock(&ucr->dev_mutex);
+       dev_dbg(sdmmc_dev(host), "%s end\n", __func__);
+}
+
+static int sdmmc_switch_voltage(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+       struct rtsx_usb_sdmmc *host = mmc_priv(mmc);
+       struct rtsx_ucr *ucr = host->ucr;
+       int err = 0;
+
+       dev_dbg(sdmmc_dev(host), "%s: signal_voltage = %d\n",
+                       __func__, ios->signal_voltage);
+
+       if (host->host_removal)
+               return -ENOMEDIUM;
+
+       if (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_120)
+               return -EPERM;
+
+       mutex_lock(&ucr->dev_mutex);
+
+       err = rtsx_usb_card_exclusive_check(ucr, RTSX_USB_SD_CARD);
+       if (err) {
+               mutex_unlock(&ucr->dev_mutex);
+               return err;
+       }
+
+       /* Let mmc core do the busy checking, simply stop the forced-toggle
+        * clock(while issuing CMD11) and switch voltage.
+        */
+       rtsx_usb_init_cmd(ucr);
+
+       if (ios->signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_PAD_CTL,
+                               SD_IO_USING_1V8, SD_IO_USING_3V3);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, LDO_POWER_CFG,
+                               TUNE_SD18_MASK, TUNE_SD18_3V3);
+       } else {
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_BUS_STAT,
+                               SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP,
+                               SD_CLK_FORCE_STOP);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_PAD_CTL,
+                               SD_IO_USING_1V8, SD_IO_USING_1V8);
+               rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, LDO_POWER_CFG,
+                               TUNE_SD18_MASK, TUNE_SD18_1V8);
+       }
+
+       err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
+       mutex_unlock(&ucr->dev_mutex);
+
+       return err;
+}
+
+static int sdmmc_card_busy(struct mmc_host *mmc)
+{
+       struct rtsx_usb_sdmmc *host = mmc_priv(mmc);
+       struct rtsx_ucr *ucr = host->ucr;
+       int err;
+       u8 stat;
+       u8 mask = SD_DAT3_STATUS | SD_DAT2_STATUS | SD_DAT1_STATUS
+               | SD_DAT0_STATUS;
+
+       dev_dbg(sdmmc_dev(host), "%s\n", __func__);
+
+       mutex_lock(&ucr->dev_mutex);
+
+       err = rtsx_usb_write_register(ucr, SD_BUS_STAT,
+                       SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP,
+                       SD_CLK_TOGGLE_EN);
+       if (err)
+               goto out;
+
+       mdelay(1);
+
+       err = rtsx_usb_read_register(ucr, SD_BUS_STAT, &stat);
+       if (err)
+               goto out;
+
+       err = rtsx_usb_write_register(ucr, SD_BUS_STAT,
+                       SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP, 0);
+out:
+       mutex_unlock(&ucr->dev_mutex);
+
+       if (err)
+               return err;
+
+       /* check if any pin between dat[0:3] is low */
+       if ((stat & mask) != mask)
+               return 1;
+       else
+               return 0;
+}
+
+static int sdmmc_execute_tuning(struct mmc_host *mmc, u32 opcode)
+{
+       struct rtsx_usb_sdmmc *host = mmc_priv(mmc);
+       struct rtsx_ucr *ucr = host->ucr;
+       int err = 0;
+
+       if (host->host_removal)
+               return -ENOMEDIUM;
+
+       mutex_lock(&ucr->dev_mutex);
+
+       if (!host->ddr_mode)
+               err = sd_tuning_rx(host, MMC_SEND_TUNING_BLOCK);
+
+       mutex_unlock(&ucr->dev_mutex);
+
+       return err;
+}
+
+static const struct mmc_host_ops rtsx_usb_sdmmc_ops = {

drivers/mmc/host/rtsx_usb_sdmmc.c line 1290

Quoted 10 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +10 -0
+       .request = sdmmc_request,
+       .set_ios = sdmmc_set_ios,
+       .get_ro = sdmmc_get_ro,
+       .get_cd = sdmmc_get_cd,
+       .start_signal_voltage_switch = sdmmc_switch_voltage,
+       .card_busy = sdmmc_card_busy,
+       .execute_tuning = sdmmc_execute_tuning,
+};
+
+#ifdef CONFIG_PM

I suppose this should be CONFIG_PM_SLEEP?

drivers/mmc/host/rtsx_usb_sdmmc.c line 1300

Quoted 10 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +10 -0
+static int rtsx_usb_sdmmc_suspend(struct platform_device *pdev,
+               pm_message_t state)
+{
+       struct rtsx_usb_sdmmc *host = platform_get_drvdata(pdev);
+       struct mmc_host *mmc = host->mmc;
+       int err;
+
+       dev_dbg(sdmmc_dev(host), "--> %s\n", __func__);
+
+       err = mmc_suspend_host(mmc);

This won't compile. The mmc_suspend_host API has been removed.

Quoted 4 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +4 -0
+       if (err)
+               return err;
+
+       return 0;

drivers/mmc/host/rtsx_usb_sdmmc.c line 1314

Quoted 10 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +10 -0
+}
+
+static int rtsx_usb_sdmmc_resume(struct platform_device *pdev)
+{
+       struct rtsx_usb_sdmmc *host = platform_get_drvdata(pdev);
+       struct mmc_host *mmc = host->mmc;
+
+       dev_dbg(sdmmc_dev(host), "--> %s\n", __func__);
+
+       return mmc_resume_host(mmc);

This won't compile. The mmc_resume_host API has been removed.

Quoted 166 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +166 -0
+}
+#else /* CONFIG_PM */
+#define rtsx_usb_sdmmc_suspend NULL
+#define rtsx_usb_sdmmc_resume NULL
+#endif /* CONFIG_PM */
+
+#ifdef RTSX_USB_USE_LEDS_CLASS
+static void rtsx_usb_led_control(struct led_classdev *led,
+       enum led_brightness brightness)
+{
+       struct rtsx_usb_sdmmc *host = container_of(led,
+                       struct rtsx_usb_sdmmc, led);
+
+       if (host->host_removal)
+               return;
+
+       host->led.brightness = brightness;
+       schedule_work(&host->led_work);
+}
+
+static void rtsx_usb_update_led(struct work_struct *work)
+{
+       struct rtsx_usb_sdmmc *host =
+               container_of(work, struct rtsx_usb_sdmmc, led_work);
+       struct rtsx_ucr *ucr = host->ucr;
+
+       mutex_lock(&ucr->dev_mutex);
+
+       if (host->led.brightness == LED_OFF)
+               rtsx_usb_turn_off_led(ucr);
+       else
+               rtsx_usb_turn_on_led(ucr);
+
+       mutex_unlock(&ucr->dev_mutex);
+}
+#endif
+
+static void rtsx_usb_init_host(struct rtsx_usb_sdmmc *host)
+{
+       struct mmc_host *mmc = host->mmc;
+
+       mmc->f_min = 250000;
+       mmc->f_max = 208000000;
+       mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34 | MMC_VDD_165_195;
+       mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_SD_HIGHSPEED |
+               MMC_CAP_MMC_HIGHSPEED | MMC_CAP_BUS_WIDTH_TEST |
+               MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | MMC_CAP_UHS_SDR50 |
+               MMC_CAP_NEEDS_POLL;
+
+       mmc->max_current_330 = 400;
+       mmc->max_current_180 = 800;
+       mmc->ops = &rtsx_usb_sdmmc_ops;
+       mmc->max_segs = 256;
+       mmc->max_seg_size = 65536;
+       mmc->max_blk_size = 512;
+       mmc->max_blk_count = 65535;
+       mmc->max_req_size = 524288;
+
+       host->power_mode = MMC_POWER_OFF;
+}
+
+static int rtsx_usb_sdmmc_drv_probe(struct platform_device *pdev)
+{
+       struct mmc_host *mmc;
+       struct rtsx_usb_sdmmc *host;
+       struct rtsx_ucr *ucr;
+#ifdef RTSX_USB_USE_LEDS_CLASS
+       int err;
+#endif
+
+       ucr = usb_get_intfdata(to_usb_interface(pdev->dev.parent));
+       if (!ucr)
+               return -ENXIO;
+
+       dev_dbg(&(pdev->dev), ": Realtek USB SD/MMC controller found\n");
+
+       mmc = mmc_alloc_host(sizeof(*host), &pdev->dev);
+       if (!mmc)
+               return -ENOMEM;
+
+       host = mmc_priv(mmc);
+       host->ucr = ucr;
+       host->mmc = mmc;
+       host->pdev = pdev;
+       platform_set_drvdata(pdev, host);
+
+       mutex_init(&host->host_mutex);
+       rtsx_usb_init_host(host);
+#ifdef CONFIG_PM_RUNTIME
+       pm_runtime_enable(&pdev->dev);
+#endif
+
+#ifdef RTSX_USB_USE_LEDS_CLASS
+       snprintf(host->led_name, sizeof(host->led_name),
+               "%s::", mmc_hostname(mmc));
+       host->led.name = host->led_name;
+       host->led.brightness = LED_OFF;
+       host->led.default_trigger = mmc_hostname(mmc);
+       host->led.brightness_set = rtsx_usb_led_control;
+
+       err = led_classdev_register(mmc_dev(mmc), &host->led);
+       if (err)
+               dev_err(&(pdev->dev),
+                               "Failed to register LED device: %d\n", err);
+       INIT_WORK(&host->led_work, rtsx_usb_update_led);
+
+#endif
+       mmc_add_host(mmc);
+
+       return 0;
+}
+
+static int rtsx_usb_sdmmc_drv_remove(struct platform_device *pdev)
+{
+       struct rtsx_usb_sdmmc *host = platform_get_drvdata(pdev);
+       struct mmc_host *mmc;
+
+       if (!host)
+               return 0;
+
+       mmc = host->mmc;
+       host->host_removal = true;
+
+       mutex_lock(&host->host_mutex);
+       if (host->mrq) {
+               dev_dbg(&(pdev->dev),
+                       "%s: Controller removed during transfer\n",
+                       mmc_hostname(mmc));
+               host->mrq->cmd->error = -ENOMEDIUM;
+               if (host->mrq->stop)
+                       host->mrq->stop->error = -ENOMEDIUM;
+               mmc_request_done(mmc, host->mrq);
+       }
+       mutex_unlock(&host->host_mutex);
+
+       mmc_remove_host(mmc);
+
+#ifdef RTSX_USB_USE_LEDS_CLASS
+       cancel_work_sync(&host->led_work);
+       led_classdev_unregister(&host->led);
+#endif
+
+       mmc_free_host(mmc);
+
+#ifdef CONFIG_PM_RUNTIME
+       /* Balance possible unbalanced usage count
+        * e.g. unconditional module removal
+        */
+       if (pm_runtime_active(&pdev->dev))
+               pm_runtime_put(&pdev->dev);
+
+       pm_runtime_disable(&pdev->dev);
+#endif
+       platform_set_drvdata(pdev, NULL);
+
+       dev_dbg(&(pdev->dev),
+               ": Realtek USB SD/MMC module has been removed\n");
+
+       return 0;
+}
+
+static struct platform_device_id rtsx_usb_sdmmc_ids[] = {
+       {
+               .name = "rtsx_usb_sdmmc",
+       }, {
+               /* sentinel */

drivers/mmc/host/rtsx_usb_sdmmc.c line 1490

Quoted 10 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +10 -0
+       }
+};
+MODULE_DEVICE_TABLE(platform, rtsx_usb_sdmmc_ids);
+
+static struct platform_driver rtsx_usb_sdmmc_driver = {
+       .probe          = rtsx_usb_sdmmc_drv_probe,
+       .remove         = rtsx_usb_sdmmc_drv_remove,
+       .id_table       = rtsx_usb_sdmmc_ids,
+       .suspend        = rtsx_usb_sdmmc_suspend,
+       .resume         = rtsx_usb_sdmmc_resume,

Please use the modern pm_ops instead of the legacy suspend/resume callbacks. I suggest you then also switch to use the SIMPLE_DEV_PM_OPS macro.

Kind regards
Ulf Hansson

Quoted 17 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +10 -1
+       .driver         = {
+               .owner  = THIS_MODULE,
+               .name   = "rtsx_usb_sdmmc",
+       },
+};
+module_platform_driver(rtsx_usb_sdmmc_driver);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Roger Tseng <[email protected]>");
+MODULE_DESCRIPTION("Realtek USB SD/MMC Card Host Driver");
--

1.8.2

--
To unsubscribe from this list: send the line "unsubscribe linux-mmc" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

A message that is not in the archive (sent off-list or not yet received): [email protected]

author
#9 lore raw

Re: [PATCH v3 2/3] mmc: Add realtek USB sdmmc host driver

Quoted 13 lines · Ulf Hansson
Quoted 12 lines · On 6 February 2014 15:35, <[email protected]> wrote:

From: Roger Tseng <[email protected]>

Realtek USB SD/MMC host driver provides mmc host support based on the Realtek USB card reader MFD driver.

---
  drivers/mmc/host/Kconfig          |    7 +
  drivers/mmc/host/Makefile         |    1 +
  drivers/mmc/host/rtsx_usb_sdmmc.c | 1500 +++++++++++++++++++++++++++++++++++++
  3 files changed, 1508 insertions(+)

create mode 100644 drivers/mmc/host/rtsx_usb_sdmmc.c

[snip]

Quoted 7 lines
Quoted 1 line

+#ifdef CONFIG_PM_RUNTIME

There are stubs for pm_runtime* functions, thus the ifdefs can be removed. Please go though the complete patch and remove all instances.

Quoted 1 line

+ pm_runtime_put(sdmmc_dev(host));

Quoted 8 lines

I don't know so much about USB mmc hosts hardware, but I just wanted to find out if I have understood this correct.

You can't do fine grained power management of the USB parent device, since it needs to be runtime resumed to be able keep the power the card? Once it becomes runtime suspended, the power to the card will thus also be dropped?

Yes, and to keep some internal state of the controller.

[snip]

Quoted 4 lines
Quoted 1 line

+#ifdef CONFIG_PM

I suppose this should be CONFIG_PM_SLEEP?

...

Quoted 4 lines
Quoted 1 line

+ err = mmc_suspend_host(mmc);

This won't compile. The mmc_suspend_host API has been removed.

...

Quoted 4 lines
Quoted 1 line

+ return mmc_resume_host(mmc);

This won't compile. The mmc_resume_host API has been removed.

...

Quoted 9 lines

drivers/mmc/host/rtsx_usb_sdmmc.c line 1490

Quoted 6 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +6 -0
+static struct platform_driver rtsx_usb_sdmmc_driver = {
+       .probe          = rtsx_usb_sdmmc_drv_probe,
+       .remove         = rtsx_usb_sdmmc_drv_remove,
+       .id_table       = rtsx_usb_sdmmc_ids,
+       .suspend        = rtsx_usb_sdmmc_suspend,
+       .resume         = rtsx_usb_sdmmc_resume,

Please use the modern pm_ops instead of the legacy suspend/resume callbacks. I suggest you then also switch to use the SIMPLE_DEV_PM_OPS macro.

I just missed the removal of mmc_suspend|resume_host.

I'll remove all these unnecessary mmc host pm things as done in commit ff71c4bcb0af2730d047989e485303ae4e1ce794 for drivers of our PCIe devices.

Thanks for pointing this out.

Quoted 2 lines

Kind regards
Ulf Hansson

#10 lore raw

Re: [PATCH v3 2/3] mmc: Add realtek USB sdmmc host driver

Quoted 33 lines · Roger
Quoted 17 lines · Ulf Hansson
Quoted 15 lines · On 6 February 2014 15:35, <[email protected]> wrote:

From: Roger Tseng <[email protected]>

Realtek USB SD/MMC host driver provides mmc host support based on the Realtek
USB card reader MFD driver.

---
  drivers/mmc/host/Kconfig          |    7 +
  drivers/mmc/host/Makefile         |    1 +
  drivers/mmc/host/rtsx_usb_sdmmc.c | 1500
+++++++++++++++++++++++++++++++++++++
  3 files changed, 1508 insertions(+)

create mode 100644 drivers/mmc/host/rtsx_usb_sdmmc.c

[snip]

Quoted 12 lines
Quoted 1 line

+#ifdef CONFIG_PM_RUNTIME

There are stubs for pm_runtime* functions, thus the ifdefs can be removed. Please go though the complete patch and remove all instances.

Quoted 1 line

+ pm_runtime_put(sdmmc_dev(host));

I don't know so much about USB mmc hosts hardware, but I just wanted to find out if I have understood this correct.

Quoted 6 lines
Quoted 5 lines

You can't do fine grained power management of the USB parent device, since it needs to be runtime resumed to be able keep the power the card? Once it becomes runtime suspended, the power to the card will thus also be dropped?

Yes, and to keep some internal state of the controller.

Okay.

But the internal state of the controller should be possible to restore at runtime_resume, so that should not be the reason, right?

Quoted 46 lines

[snip]

Quoted 5 lines
Quoted 1 line

+#ifdef CONFIG_PM

I suppose this should be CONFIG_PM_SLEEP?

...

Quoted 5 lines
Quoted 1 line

+ err = mmc_suspend_host(mmc);

This won't compile. The mmc_suspend_host API has been removed.

...

Quoted 5 lines
Quoted 1 line

+ return mmc_resume_host(mmc);

This won't compile. The mmc_resume_host API has been removed.

...

Quoted 9 lines

drivers/mmc/host/rtsx_usb_sdmmc.c line 1490

Quoted 7 lines
drivers/mmc/host/rtsx_usb_sdmmc.c new file +6 -0
+static struct platform_driver rtsx_usb_sdmmc_driver = {
+       .probe          = rtsx_usb_sdmmc_drv_probe,
+       .remove         = rtsx_usb_sdmmc_drv_remove,
+       .id_table       = rtsx_usb_sdmmc_ids,
+       .suspend        = rtsx_usb_sdmmc_suspend,
+       .resume         = rtsx_usb_sdmmc_resume,
Quoted 3 lines

Please use the modern pm_ops instead of the legacy suspend/resume callbacks.
I suggest you then also switch to use the SIMPLE_DEV_PM_OPS macro.

I just missed the removal of mmc_suspend|resume_host.

I'll remove all these unnecessary mmc host pm things as done in commit ff71c4bcb0af2730d047989e485303ae4e1ce794 for drivers of our PCIe devices.

Thanks for pointing this out.

Quoted 2 lines

Kind regards
Ulf Hansson

A message that is not in the archive (sent off-list or not yet received): [email protected]

author
#12 lore raw

Re: [PATCH v3 2/3] mmc: Add realtek USB sdmmc host driver

Quoted 39 lines · Ulf Hansson
Quoted 38 lines · Roger
Quoted 17 lines · Ulf Hansson
Quoted 15 lines · On 6 February 2014 15:35, <[email protected]> wrote:

From: Roger Tseng <[email protected]>

Realtek USB SD/MMC host driver provides mmc host support based on the Realtek
USB card reader MFD driver.

---
   drivers/mmc/host/Kconfig          |    7 +
   drivers/mmc/host/Makefile         |    1 +
   drivers/mmc/host/rtsx_usb_sdmmc.c | 1500
+++++++++++++++++++++++++++++++++++++
   3 files changed, 1508 insertions(+)

create mode 100644 drivers/mmc/host/rtsx_usb_sdmmc.c

[snip]

Quoted 17 lines
Quoted 1 line

+#ifdef CONFIG_PM_RUNTIME

There are stubs for pm_runtime* functions, thus the ifdefs can be removed. Please go though the complete patch and remove all instances.

Quoted 1 line

+ pm_runtime_put(sdmmc_dev(host));

I don't know so much about USB mmc hosts hardware, but I just wanted to find out if I have understood this correct.

You can't do fine grained power management of the USB parent device, since it needs to be runtime resumed to be able keep the power the card? Once it becomes runtime suspended, the power to the card will thus also be dropped?

Quoted 7 lines
Quoted 1 line

Yes, and to keep some internal state of the controller.

Okay.

But the internal state of the controller should be possible to restore at runtime_resume, so that should not be the reason, right?

I checked again. Internal registers will hold its state during suspend. Card power is the exact reason.

Quoted 4 lines
Quoted 2 lines
Quoted 2 lines

Kind regards
Ulf Hansson

.

#13 lore raw

PATCH v3 3/3 memstick: Add realtek USB memstick host driver

In reply to [email protected]

From: Roger Tseng <[email protected]>

Realtek USB memstick host driver provides memstick host support based on the Realtek USB card reader MFD driver.

---
 drivers/memstick/host/Kconfig       |  10 +
 drivers/memstick/host/Makefile      |   1 +
 drivers/memstick/host/rtsx_usb_ms.c | 849 ++++++++++++++++++++++++++++++++++++
 3 files changed, 860 insertions(+)
 create mode 100644 drivers/memstick/host/rtsx_usb_ms.c
drivers/memstick/host/Kconfig +10 -0
index 1b37cf8..7310e32 100644
@@ -52,3 +52,13 @@ config MEMSTICK_REALTEK_PCI
 
 	  To compile this driver as a module, choose M here: the module will
 	  be called rtsx_pci_ms.
+
+config MEMSTICK_REALTEK_USB
+	tristate "Realtek USB Memstick Card Interface Driver"
+	depends on MFD_RTSX_USB
+	help
+	  Say Y here to include driver code to support Memstick card interface
+	  of Realtek RTS5129/39 series USB card reader
+
+	  To compile this driver as a module, choose M here: the module will
+	  be called rts5139_ms.
drivers/memstick/host/Makefile +1 -0
index af3459d..491c955 100644
@@ -6,3 +6,4 @@ obj-$(CONFIG_MEMSTICK_TIFM_MS)		+= tifm_ms.o
 obj-$(CONFIG_MEMSTICK_JMICRON_38X)	+= jmb38x_ms.o
 obj-$(CONFIG_MEMSTICK_R592)		+= r592.o
 obj-$(CONFIG_MEMSTICK_REALTEK_PCI)	+= rtsx_pci_ms.o
+obj-$(CONFIG_MEMSTICK_REALTEK_USB)	+= rtsx_usb_ms.o
drivers/memstick/host/rtsx_usb_ms.c new file +849 -0

849 lines not on this page · raw message

Signature · 1 line
1.8.2
Acked-by on the v3 series
#14 lore raw
In reply to [email protected]
Quoted 23 lines · On Thu, Feb 06, 2014 at 10:35:04PM +0800, [email protected] wrote:

From: Roger Tseng <[email protected]>

This patchset adds modules to support Realtek USB vendor specific class flash card reader: one base module in MFD subsystem and two host modules in both mmc and memstick subsystems. The architecture is similar to rtsx_pci.

This work is done primarily to replace the staging driver: staging/rts5139, which doesn't utilize mmc nor memstick subsystems. Once the patchset or its revision is applied, we may need Greg's help to remove the staging one.

v2:
1. Fix potential buffer overflow in rtsx_usb_seq_write_register()
2. Remove unnecessary casting and messages
3. Revise coding style and white spaces

v3:
1. Fix MMC detection fail when under xhci
2. Minor change of pm_runtime behavior in rtsx_usb_ms to prevent some rare freeze due to erroneous Memstick card(not MS-Pro)
3. Further revise coding style as suggested in the thread of v2
4. Using managed resources: devm_*
5. Change license from "GPL v2 and later" to "GPL v2"

Quoted 4 lines

Roger Tseng (3):
mfd: Add realtek USB card reader driver
mmc: Add realtek USB sdmmc host driver
memstick: Add realtek USB memstick host driver

Looks good to me, thanks for doing this work: