Skip to contentSkip to conversation

Add modules for realtek USB card reader

PATCH Superseded [email protected] 5 participants 20 messages Feb 12, 2014 – Mar 21, 2014

Subsystems (3)

v4 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

v4 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"

v4:
1. Remove invocations to deprecated/removed mmc_suspend|resume_host APIs and unnecessary platform device pm routines
2. Support CRC-ignored R1 response for CMD13 in response to commit:
a27fbf2f067b0cd6f172c8b696b9a44c58bfaa7a: mmc: add ignorance case for CMD13 CRC error
3. Remove unnecessary #ifdef CONFIG_PM_RUNTIME

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 |  836 ++++++++++++++++++++
 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   | 1462 +++++++++++++++++++++++++++++++++++
 include/linux/mfd/rtsx_usb.h        |  628 +++++++++++++++
 10 files changed, 3716 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 v4 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 v4 1/3] mfd: Add realtek USB card reader driver

Quoted 7 lines · On Wed, 12 Feb 2014, [email protected] wrote:

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 again, thanks.

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 v4 1/3] mfd: Add realtek USB card reader driver

Quoted 18 lines · Lee Jones
Quoted 7 lines · On Wed, 12 Feb 2014, [email protected] wrote:

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 again, thanks.

Would you also apply patch 2/3 and 3/3 that to make the device fully operational for users? Or should they be applied by maintainers of mmc/memstick subsystems?

Chris, would you give some comment?

#4 lore raw

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

Quoted 16 lines
Quoted 16 lines
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 again, thanks.

Would you also apply patch 2/3 and 3/3 that to make the device fully operational for users? Or should they be applied by maintainers of mmc/memstick subsystems?

Chris, would you give some comment?

I can apply them, but I need the other Maintainer Acks.

If they are build orthogonal i.e. there are no build dependencies between them, it's probably better that they go into their associated trees separately.

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

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

Quoted 22 lines · Lee Jones
Quoted 22 lines
Quoted 16 lines
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 again, thanks.

Would you also apply patch 2/3 and 3/3 that to make the device fully operational for users? Or should they be applied by maintainers of mmc/memstick subsystems?

Quoted 8 lines
Quoted 1 line

Chris, would you give some comment?

I can apply them, but I need the other Maintainer Acks.

If they are build orthogonal i.e. there are no build dependencies between them, it's probably better that they go into their associated trees separately.

I think it would be better to apply them together since the later patches really depend on the 1st one,so now we are waiting for Acks from mmc/memstick subsystems.

But there is no one specified for "memstick/host/" in MAINTAINERS. Could anyone else Ack this?

#6 lore raw

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

Quoted 26 lines
Quoted 26 lines
Quoted 16 lines
Quoted 16 lines
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 again, thanks.

Would you also apply patch 2/3 and 3/3 that to make the device fully operational for users? Or should they be applied by maintainers of mmc/memstick subsystems?

Chris, would you give some comment?

I can apply them, but I need the other Maintainer Acks.

Quoted 7 lines
Quoted 4 lines

If they are build orthogonal i.e. there are no build dependencies between them, it's probably better that they go into their associated trees separately.

I think it would be better to apply them together since the later patches really depend on the 1st one,so now we are waiting for Acks from mmc/memstick subsystems.

When you say "depend on", do you mean as a build depenency, or won't run without the first patch applied?

Quoted 2 lines

But there is no one specified for "memstick/host/" in MAINTAINERS. Could anyone else Ack this?

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

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

Quoted 30 lines · Lee Jones
Quoted 30 lines
Quoted 30 lines
Quoted 16 lines
Quoted 16 lines
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 again, thanks.

Would you also apply patch 2/3 and 3/3 that to make the device fully operational for users? Or should they be applied by maintainers of mmc/memstick subsystems?

Chris, would you give some comment?

I can apply them, but I need the other Maintainer Acks.

If they are build orthogonal i.e. there are no build dependencies between them, it's probably better that they go into their associated trees separately.

Quoted 6 lines
Quoted 3 lines

I think it would be better to apply them together since the later patches really depend on the 1st one,so now we are waiting for Acks from mmc/memstick subsystems.

When you say "depend on", do you mean as a build depenency, or won't run without the first patch applied?

The later 2 patches actually invoke symbols defined in the first patch and won't compile if it is not applied first. The Kconfig changes for the later oness also specified this by "depends on".

I'm not sure if this means "build dependency". Sorry for my unclear words.

Quoted 3 lines
Quoted 2 lines

But there is no one specified for "memstick/host/" in MAINTAINERS. Could anyone else Ack this?

#8 lore raw

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

Quoted 34 lines
Quoted 34 lines
Quoted 33 lines
Quoted 22 lines
Quoted 22 lines
Quoted 16 lines
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 again, thanks.

Would you also apply patch 2/3 and 3/3 that to make the device fully operational for users? Or should they be applied by maintainers of mmc/memstick subsystems?

Quoted 8 lines
Quoted 1 line

Chris, would you give some comment?

I can apply them, but I need the other Maintainer Acks.

If they are build orthogonal i.e. there are no build dependencies between them, it's probably better that they go into their associated trees separately.

I think it would be better to apply them together since the later patches really depend on the 1st one,so now we are waiting for Acks from mmc/memstick subsystems.

Quoted 8 lines
Quoted 2 lines

When you say "depend on", do you mean as a build depenency, or won't run without the first patch applied?

The later 2 patches actually invoke symbols defined in the first patch and won't compile if it is not applied first. The Kconfig changes for the later oness also specified this by "depends on".

I'm not sure if this means "build dependency". Sorry for my unclear words.

Yes, that sounds like a build dependency i.e. will not build without errors or warnings without the previous patch applied.

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines

But there is no one specified for "memstick/host/" in MAINTAINERS. Could anyone else Ack this?

Andrew (CC'ed) has been Acking these thus far.

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
author
#9 lore raw

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

Quoted 43 lines · Lee Jones
Quoted 34 lines
Quoted 34 lines
Quoted 33 lines
Quoted 22 lines
Quoted 22 lines
Quoted 16 lines
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 again, thanks.

Would you also apply patch 2/3 and 3/3 that to make the device fully operational for users? Or should they be applied by maintainers of mmc/memstick subsystems?

Quoted 8 lines
Quoted 1 line

Chris, would you give some comment?

I can apply them, but I need the other Maintainer Acks.

If they are build orthogonal i.e. there are no build dependencies between them, it's probably better that they go into their associated trees separately.

I think it would be better to apply them together since the later patches really depend on the 1st one,so now we are waiting for Acks from mmc/memstick subsystems.

Quoted 8 lines
Quoted 2 lines

When you say "depend on", do you mean as a build depenency, or won't run without the first patch applied?

The later 2 patches actually invoke symbols defined in the first patch and won't compile if it is not applied first. The Kconfig changes for the later oness also specified this by "depends on".

I'm not sure if this means "build dependency". Sorry for my unclear words.

Quoted 8 lines

Yes, that sounds like a build dependency i.e. will not build without errors or warnings without the previous patch applied.

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines

But there is no one specified for "memstick/host/" in MAINTAINERS. Could anyone else Ack this?

Andrew (CC'ed) has been Acking these thus far.

Hi Chris and Andrew,

Would you please help comment PATCH 2/3 and 3/3 (for mmc and memstick, respectively) or give Acks? Thus we can proceed with applying or revision if necessary.

Acked-by
#10 lore raw

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

Hi,

Quoted 3 lines · Roger

Would you please help comment PATCH 2/3 and 3/3 (for mmc and memstick, respectively) or give Acks? Thus we can proceed with applying or revision if necessary.

For 2/3:

Thanks,

- Chris.

Signature · 1 line
Chris Ball   <[email protected]>   <http://printf.net/>
author
#11 lore raw

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

Quoted 7 lines · Chris Ball

Hi,

Quoted 3 lines · Roger

Would you please help comment PATCH 2/3 and 3/3 (for mmc and memstick, respectively) or give Acks? Thus we can proceed with applying or revision if necessary.

Quoted 8 lines

For 2/3:

Thanks,

- Chris.

Hi Andrew,

Could you please give some comment to the 3/3(memstick) patch?

Best regards,
Roger Tseng

author
#12 lore raw

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

Quoted 12 lines · Roger
Quoted 11 lines · Chris Ball

Hi,

Quoted 3 lines · Roger

Would you please help comment PATCH 2/3 and 3/3 (for mmc and memstick, respectively) or give Acks? Thus we can proceed with applying or revision if necessary.

For 2/3:

Quoted 8 lines
Quoted 4 lines

Thanks,

- Chris.

Hi Andrew,

Could you please give some comment to the 3/3(memstick) patch?

Lee has introduced and CC'ed AKPM for acking the memstick patch (3/3)
several weeks ago but so far we haven't get any response. Thus the merge of all 3 patches is blocked. Is there anyone else can help this or anything else I could do?

Best regards,
Roger Tseng

#13 lore raw

PATCH v4 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 | 1462 +++++++++++++++++++++++++++++++++++++
 3 files changed, 1470 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 +1462 -0

1,462 lines not on this page · raw message

Signature · 1 line
1.8.2
Reviewed-by on v4 2/3
#14 lore raw

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

Quoted 6 lines · On 12 February 2014 11:00, <[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.

Quoted 1,505 lines
---
 drivers/mmc/host/Kconfig          |    7 +
 drivers/mmc/host/Makefile         |    1 +
 drivers/mmc/host/rtsx_usb_sdmmc.c | 1462 +++++++++++++++++++++++++++++++++++++
 3 files changed, 1470 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 +1462 -1
new file mode 100644
index 0000000..37f58b5
@@ -0,0 +1,1462 @@
+/* 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_R1 & ~MMC_RSP_CRC:
+               rsp_type = SD_RSP_TYPE_R1 | SD_NO_CHECK_CRC7;
+               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;
+       }
+
+       /*
+        * 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;
+       }
+
+       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;
+
+       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);
+               pm_runtime_put(sdmmc_dev(host));
+       } else {
+               pm_runtime_get_sync(sdmmc_dev(host));
+               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 = {
+       .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 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);
+       pm_runtime_enable(&pdev->dev);
+
+#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);
+
+       /* 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);
+       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 */
+       }
+};
+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,
+       .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

#15 lore raw

PATCH v4 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 | 836 ++++++++++++++++++++++++++++++++++++
 3 files changed, 847 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 +836 -0

836 lines not on this page · raw message

Signature · 1 line
1.8.2
author
#16 lore raw

Re: [PATCH v4 3/3] memstick: Add realtek USB memstick host driver

Quoted 6 lines · On 02/12/2014 06:00 PM, [email protected] wrote:

From: Roger Tseng <[email protected]>

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

Andrew,

Would you please Ack or comment this patch(3/3) to let the 3 patches be merged together? I have been making the same request at the message thread of "[PATCH v4 2/3]" since several weeks ago but got no response. Thus I re-post here and hope I could get something.

Best regards,
Roger Tseng

Quoted 877 lines
---
  drivers/memstick/host/Kconfig       |  10 +
  drivers/memstick/host/Makefile      |   1 +
  drivers/memstick/host/rtsx_usb_ms.c | 836 ++++++++++++++++++++++++++++++++++++
  3 files changed, 847 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 +836 -0
new file mode 100644
index 0000000..eb4c75d
@@ -0,0 +1,836 @@
+/* Realtek USB Memstick 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/highmem.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+#include <linux/memstick.h>
+#include <linux/kthread.h>
+#include <linux/mfd/rtsx_usb.h>
+#include <linux/pm_runtime.h>
+#include <asm/unaligned.h>
+
+struct rtsx_usb_ms {
+	struct platform_device	*pdev;
+	struct rtsx_ucr	*ucr;
+	struct memstick_host	*msh;
+	struct memstick_request	*req;
+
+	struct mutex		host_mutex;
+	struct work_struct	handle_req;
+
+	struct task_struct	*detect_ms;
+	struct completion	detect_ms_exit;
+
+	u8			ssc_depth;
+	unsigned int		clock;
+	int			power_mode;
+	unsigned char           ifmode;
+	bool			eject;
+};
+
+static inline struct device *ms_dev(struct rtsx_usb_ms *host)
+{
+	return &(host->pdev->dev);
+}
+
+static inline void ms_clear_error(struct rtsx_usb_ms *host)
+{
+	struct rtsx_ucr *ucr = host->ucr;
+	rtsx_usb_ep0_write_register(ucr, CARD_STOP,
+				  MS_STOP | MS_CLR_ERR,
+				  MS_STOP | MS_CLR_ERR);
+
+	rtsx_usb_clear_dma_err(ucr);
+	rtsx_usb_clear_fsm_err(ucr);
+}
+
+#ifdef DEBUG
+
+static void ms_print_debug_regs(struct rtsx_usb_ms *host)
+{
+	struct rtsx_ucr *ucr = host->ucr;
+	u16 i;
+	u8 *ptr;
+
+	/* Print MS host internal registers */
+	rtsx_usb_init_cmd(ucr);
+
+	/* MS_CFG to MS_INT_REG */
+	for (i = 0xFD40; i <= 0xFD44; i++)
+		rtsx_usb_add_cmd(ucr, READ_REG_CMD, i, 0, 0);
+
+	/* CARD_SHARE_MODE to CARD_GPIO */
+	for (i = 0xFD51; i <= 0xFD56; i++)
+		rtsx_usb_add_cmd(ucr, READ_REG_CMD, i, 0, 0);
+
+	/* CARD_PULL_CTLx */
+	for (i = 0xFD60; i <= 0xFD65; i++)
+		rtsx_usb_add_cmd(ucr, READ_REG_CMD, i, 0, 0);
+
+	/* CARD_DATA_SOURCE, CARD_SELECT, CARD_CLK_EN, CARD_PWR_CTL */
+	rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_DATA_SOURCE, 0, 0);
+	rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_SELECT, 0, 0);
+	rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_CLK_EN, 0, 0);
+	rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_PWR_CTL, 0, 0);
+
+	rtsx_usb_send_cmd(ucr, MODE_CR, 100);
+	rtsx_usb_get_rsp(ucr, 21, 100);
+
+	ptr = ucr->rsp_buf;
+	for (i = 0xFD40; i <= 0xFD44; i++)
+		dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
+	for (i = 0xFD51; i <= 0xFD56; i++)
+		dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
+	for (i = 0xFD60; i <= 0xFD65; i++)
+		dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
+
+	dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_DATA_SOURCE, *(ptr++));
+	dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_SELECT, *(ptr++));
+	dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_CLK_EN, *(ptr++));
+	dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_PWR_CTL, *(ptr++));
+}
+
+#else
+
+#define ms_print_debug_regs(host)
+
+#endif
+static int ms_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 ms_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 ms_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, 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 ms_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, 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, 0x55);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0x59);
+
+	return rtsx_usb_send_cmd(ucr, MODE_C, 100);
+}
+
+static int ms_power_on(struct rtsx_usb_ms *host)
+{
+	struct rtsx_ucr *ucr = host->ucr;
+	int err;
+
+	dev_dbg(ms_dev(host), "%s\n", __func__);
+
+	rtsx_usb_init_cmd(ucr);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_SELECT, 0x07, MS_MOD_SEL);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_SHARE_MODE,
+			CARD_SHARE_MASK, CARD_SHARE_MS);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_EN,
+			MS_CLK_EN, MS_CLK_EN);
+	err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
+	if (err < 0)
+		return err;
+
+	if (CHECK_PKG(ucr, LQFP48))
+		err = ms_pull_ctl_enable_lqfp48(ucr);
+	else
+		err = ms_pull_ctl_enable_qfn24(ucr);
+	if (err < 0)
+		return err;
+
+	err = rtsx_usb_write_register(ucr, CARD_PWR_CTL,
+			POWER_MASK, PARTIAL_POWER_ON);
+	if (err)
+		return err;
+
+	/* Wait ms power stable */
+	usleep_range(800, 1000);
+
+	rtsx_usb_init_cmd(ucr);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
+			POWER_MASK, POWER_ON);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_OE,
+			MS_OUTPUT_EN, MS_OUTPUT_EN);
+
+	return rtsx_usb_send_cmd(ucr, MODE_C, 100);
+}
+
+static int ms_power_off(struct rtsx_usb_ms *host)
+{
+	struct rtsx_ucr *ucr = host->ucr;
+	int err;
+
+	dev_dbg(ms_dev(host), "%s\n", __func__);
+
+	rtsx_usb_init_cmd(ucr);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_EN, MS_CLK_EN, 0);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_OE, MS_OUTPUT_EN, 0);
+
+	err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
+	if (err < 0)
+		return err;
+
+	if (CHECK_PKG(ucr, LQFP48))
+		return ms_pull_ctl_disable_lqfp48(ucr);
+
+	return ms_pull_ctl_disable_qfn24(ucr);
+}
+
+static int ms_transfer_data(struct rtsx_usb_ms *host, unsigned char data_dir,
+		u8 tpc, u8 cfg, struct scatterlist *sg)
+{
+	struct rtsx_ucr *ucr = host->ucr;
+	int err;
+	unsigned int length = sg->length;
+	u16 sec_cnt = (u16)(length / 512);
+	u8 trans_mode, dma_dir, flag;
+	unsigned int pipe;
+	struct memstick_dev *card = host->msh->card;
+
+	dev_dbg(ms_dev(host), "%s: tpc = 0x%02x, data_dir = %s, length = %d\n",
+			__func__, tpc, (data_dir == READ) ? "READ" : "WRITE",
+			length);
+
+	if (data_dir == READ) {
+		flag = MODE_CDIR;
+		dma_dir = DMA_DIR_FROM_CARD;
+		if (card->id.type != MEMSTICK_TYPE_PRO)
+			trans_mode = MS_TM_NORMAL_READ;
+		else
+			trans_mode = MS_TM_AUTO_READ;
+		pipe = usb_rcvbulkpipe(ucr->pusb_dev, EP_BULK_IN);
+	} else {
+		flag = MODE_CDOR;
+		dma_dir = DMA_DIR_TO_CARD;
+		if (card->id.type != MEMSTICK_TYPE_PRO)
+			trans_mode = MS_TM_NORMAL_WRITE;
+		else
+			trans_mode = MS_TM_AUTO_WRITE;
+		pipe = usb_sndbulkpipe(ucr->pusb_dev, EP_BULK_OUT);
+	}
+
+	rtsx_usb_init_cmd(ucr);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
+	if (card->id.type == MEMSTICK_TYPE_PRO) {
+		rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_SECTOR_CNT_H,
+				0xFF, (u8)(sec_cnt >> 8));
+		rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_SECTOR_CNT_L,
+				0xFF, (u8)sec_cnt);
+	}
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC3,
+			0xFF, (u8)(length >> 24));
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC2,
+			0xFF, (u8)(length >> 16));
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC1,
+			0xFF, (u8)(length >> 8));
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC0, 0xFF,
+			(u8)length);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_CTL,
+			0x03 | DMA_PACK_SIZE_MASK, dma_dir | DMA_EN | DMA_512);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
+			0x01, RING_BUFFER);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
+			0xFF, MS_TRANSFER_START | trans_mode);
+	rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
+			MS_TRANSFER_END, MS_TRANSFER_END);
+
+	err = rtsx_usb_send_cmd(ucr, flag | STAGE_MS_STATUS, 100);
+	if (err)
+		return err;
+
+	err = rtsx_usb_transfer_data(ucr, pipe, sg, length,
+			1, NULL, 10000);
+	if (err)
+		goto err_out;
+
+	err = rtsx_usb_get_rsp(ucr, 3, 15000);
+	if (err)
+		goto err_out;
+
+	if (ucr->rsp_buf[0] & MS_TRANSFER_ERR ||
+	    ucr->rsp_buf[1] & (MS_CRC16_ERR | MS_RDY_TIMEOUT)) {
+		err = -EIO;
+		goto err_out;
+	}
+	return 0;
+err_out:
+	ms_clear_error(host);
+	return err;
+}
+
+static int ms_write_bytes(struct rtsx_usb_ms *host, u8 tpc,
+		u8 cfg, u8 cnt, u8 *data, u8 *int_reg)
+{
+	struct rtsx_ucr *ucr = host->ucr;
+	int err, i;
+
+	dev_dbg(ms_dev(host), "%s: tpc = 0x%02x\n", __func__, tpc);
+
+	if (!data)
+		return -EINVAL;
+
+	rtsx_usb_init_cmd(ucr);
+
+	for (i = 0; i < cnt; i++)
+		rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+				PPBUF_BASE2 + i, 0xFF, data[i]);
+
+	if (cnt % 2)
+		rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+				PPBUF_BASE2 + i, 0xFF, 0xFF);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
+			0x01, PINGPONG_BUFFER);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
+			0xFF, MS_TRANSFER_START | MS_TM_WRITE_BYTES);
+	rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
+			MS_TRANSFER_END, MS_TRANSFER_END);
+	rtsx_usb_add_cmd(ucr, READ_REG_CMD, MS_TRANS_CFG, 0, 0);
+
+	err = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
+	if (err)
+		return err;
+
+	err = rtsx_usb_get_rsp(ucr, 2, 5000);
+	if (err || (ucr->rsp_buf[0] & MS_TRANSFER_ERR)) {
+		u8 val;
+
+		rtsx_usb_ep0_read_register(ucr, MS_TRANS_CFG, &val);
+		dev_dbg(ms_dev(host), "MS_TRANS_CFG: 0x%02x\n", val);
+
+		if (int_reg)
+			*int_reg = val & 0x0F;
+
+		ms_print_debug_regs(host);
+
+		ms_clear_error(host);
+
+		if (!(tpc & 0x08)) {
+			if (val & MS_CRC16_ERR)
+				return -EIO;
+		} else {
+			if (!(val & 0x80)) {
+				if (val & (MS_INT_ERR | MS_INT_CMDNK))
+					return -EIO;
+			}
+		}
+
+		return -ETIMEDOUT;
+	}
+
+	if (int_reg)
+		*int_reg = ucr->rsp_buf[1] & 0x0F;
+
+	return 0;
+}
+
+static int ms_read_bytes(struct rtsx_usb_ms *host, u8 tpc,
+		u8 cfg, u8 cnt, u8 *data, u8 *int_reg)
+{
+	struct rtsx_ucr *ucr = host->ucr;
+	int err, i;
+	u8 *ptr;
+
+	dev_dbg(ms_dev(host), "%s: tpc = 0x%02x\n", __func__, tpc);
+
+	if (!data)
+		return -EINVAL;
+
+	rtsx_usb_init_cmd(ucr);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
+			0x01, PINGPONG_BUFFER);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
+			0xFF, MS_TRANSFER_START | MS_TM_READ_BYTES);
+	rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
+			MS_TRANSFER_END, MS_TRANSFER_END);
+	for (i = 0; i < cnt - 1; i++)
+		rtsx_usb_add_cmd(ucr, READ_REG_CMD, PPBUF_BASE2 + i, 0, 0);
+	if (cnt % 2)
+		rtsx_usb_add_cmd(ucr, READ_REG_CMD, PPBUF_BASE2 + cnt, 0, 0);
+	else
+		rtsx_usb_add_cmd(ucr, READ_REG_CMD,
+				PPBUF_BASE2 + cnt - 1, 0, 0);
+
+	rtsx_usb_add_cmd(ucr, READ_REG_CMD, MS_TRANS_CFG, 0, 0);
+
+	err = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
+	if (err)
+		return err;
+
+	err = rtsx_usb_get_rsp(ucr, cnt + 2, 5000);
+	if (err || (ucr->rsp_buf[0] & MS_TRANSFER_ERR)) {
+		u8 val;
+
+		rtsx_usb_ep0_read_register(ucr, MS_TRANS_CFG, &val);
+		dev_dbg(ms_dev(host), "MS_TRANS_CFG: 0x%02x\n", val);
+
+		if (int_reg && (host->ifmode != MEMSTICK_SERIAL))
+			*int_reg = val & 0x0F;
+
+		ms_print_debug_regs(host);
+
+		ms_clear_error(host);
+
+		if (!(tpc & 0x08)) {
+			if (val & MS_CRC16_ERR)
+				return -EIO;
+		} else {
+			if (!(val & 0x80)) {
+				if (val & (MS_INT_ERR | MS_INT_CMDNK))
+					return -EIO;
+			}
+		}
+
+		return -ETIMEDOUT;
+	}
+
+	ptr = ucr->rsp_buf + 1;
+	for (i = 0; i < cnt; i++)
+		data[i] = *ptr++;
+
+
+	if (int_reg && (host->ifmode != MEMSTICK_SERIAL))
+		*int_reg = *ptr & 0x0F;
+
+	return 0;
+}
+
+static int rtsx_usb_ms_issue_cmd(struct rtsx_usb_ms *host)
+{
+	struct memstick_request *req = host->req;
+	int err = 0;
+	u8 cfg = 0, int_reg;
+
+	dev_dbg(ms_dev(host), "%s\n", __func__);
+
+	if (req->need_card_int) {
+		if (host->ifmode != MEMSTICK_SERIAL)
+			cfg = WAIT_INT;
+	}
+
+	if (req->long_data) {
+		err = ms_transfer_data(host, req->data_dir,
+				req->tpc, cfg, &(req->sg));
+	} else {
+		if (req->data_dir == READ)
+			err = ms_read_bytes(host, req->tpc, cfg,
+					req->data_len, req->data, &int_reg);
+		else
+			err = ms_write_bytes(host, req->tpc, cfg,
+					req->data_len, req->data, &int_reg);
+	}
+	if (err < 0)
+		return err;
+
+	if (req->need_card_int) {
+		if (host->ifmode == MEMSTICK_SERIAL) {
+			err = ms_read_bytes(host, MS_TPC_GET_INT,
+					NO_WAIT_INT, 1, &req->int_reg, NULL);
+			if (err < 0)
+				return err;
+		} else {
+
+			if (int_reg & MS_INT_CMDNK)
+				req->int_reg |= MEMSTICK_INT_CMDNAK;
+			if (int_reg & MS_INT_BREQ)
+				req->int_reg |= MEMSTICK_INT_BREQ;
+			if (int_reg & MS_INT_ERR)
+				req->int_reg |= MEMSTICK_INT_ERR;
+			if (int_reg & MS_INT_CED)
+				req->int_reg |= MEMSTICK_INT_CED;
+		}
+		dev_dbg(ms_dev(host), "int_reg: 0x%02x\n", req->int_reg);
+	}
+
+	return 0;
+}
+
+static void rtsx_usb_ms_handle_req(struct work_struct *work)
+{
+	struct rtsx_usb_ms *host = container_of(work,
+			struct rtsx_usb_ms, handle_req);
+	struct rtsx_ucr *ucr = host->ucr;
+	struct memstick_host *msh = host->msh;
+	int rc;
+
+	if (!host->req) {
+		do {
+			rc = memstick_next_req(msh, &host->req);
+			dev_dbg(ms_dev(host), "next req %d\n", rc);
+
+			if (!rc) {
+				mutex_lock(&ucr->dev_mutex);
+
+				if (rtsx_usb_card_exclusive_check(ucr,
+							RTSX_USB_MS_CARD))
+					host->req->error = -EIO;
+				else
+					host->req->error =
+						rtsx_usb_ms_issue_cmd(host);
+
+				mutex_unlock(&ucr->dev_mutex);
+
+				dev_dbg(ms_dev(host), "req result %d\n",
+						host->req->error);
+			}
+		} while (!rc);
+	}
+
+}
+
+static void rtsx_usb_ms_request(struct memstick_host *msh)
+{
+	struct rtsx_usb_ms *host = memstick_priv(msh);
+
+	dev_dbg(ms_dev(host), "--> %s\n", __func__);
+
+	schedule_work(&host->handle_req);
+}
+
+static int rtsx_usb_ms_set_param(struct memstick_host *msh,
+		enum memstick_param param, int value)
+{
+	struct rtsx_usb_ms *host = memstick_priv(msh);
+	struct rtsx_ucr *ucr = host->ucr;
+	unsigned int clock = 0;
+	u8 ssc_depth = 0;
+	int err;
+
+	dev_dbg(ms_dev(host), "%s: param = %d, value = %d\n",
+			__func__, param, value);
+
+	mutex_lock(&ucr->dev_mutex);
+
+	err = rtsx_usb_card_exclusive_check(ucr, RTSX_USB_MS_CARD);
+	if (err)
+		goto out;
+
+	switch (param) {
+	case MEMSTICK_POWER:
+		if (value == host->power_mode)
+			break;
+
+		if (value == MEMSTICK_POWER_ON) {
+			pm_runtime_get_sync(ms_dev(host));
+			err = ms_power_on(host);
+		} else if (value == MEMSTICK_POWER_OFF) {
+			err = ms_power_off(host);
+			if (host->msh->card)
+				pm_runtime_put_noidle(ms_dev(host));
+			else
+				pm_runtime_put(ms_dev(host));
+		} else
+			err = -EINVAL;
+		if (!err)
+			host->power_mode = value;
+		break;
+
+	case MEMSTICK_INTERFACE:
+		if (value == MEMSTICK_SERIAL) {
+			clock = 19000000;
+			ssc_depth = SSC_DEPTH_512K;
+			err = rtsx_usb_write_register(ucr, MS_CFG, 0x5A,
+				       MS_BUS_WIDTH_1 | PUSH_TIME_DEFAULT);
+			if (err < 0)
+				break;
+		} else if (value == MEMSTICK_PAR4) {
+			clock = 39000000;
+			ssc_depth = SSC_DEPTH_1M;
+
+			err = rtsx_usb_write_register(ucr, MS_CFG, 0x5A,
+					MS_BUS_WIDTH_4 | PUSH_TIME_ODD |
+					MS_NO_CHECK_INT);
+			if (err < 0)
+				break;
+		} else {
+			err = -EINVAL;
+			break;
+		}
+
+		err = rtsx_usb_switch_clock(ucr, clock,
+				ssc_depth, false, true, false);
+		if (err < 0) {
+			dev_dbg(ms_dev(host), "switch clock failed\n");
+			break;
+		}
+
+		host->ssc_depth = ssc_depth;
+		host->clock = clock;
+		host->ifmode = value;
+		break;
+	default:
+		err = -EINVAL;
+		break;
+	}
+out:
+	mutex_unlock(&ucr->dev_mutex);
+
+	/* power-on delay */
+	if (param == MEMSTICK_POWER && value == MEMSTICK_POWER_ON)
+		usleep_range(10000, 12000);
+
+	dev_dbg(ms_dev(host), "%s: return = %d\n", __func__, err);
+	return err;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int rtsx_usb_ms_suspend(struct device *dev)
+{
+	struct rtsx_usb_ms *host = dev_get_drvdata(dev);
+	struct memstick_host *msh = host->msh;
+
+	dev_dbg(ms_dev(host), "--> %s\n", __func__);
+
+	memstick_suspend_host(msh);
+	return 0;
+}
+
+static int rtsx_usb_ms_resume(struct device *dev)
+{
+	struct rtsx_usb_ms *host = dev_get_drvdata(dev);
+	struct memstick_host *msh = host->msh;
+
+	dev_dbg(ms_dev(host), "--> %s\n", __func__);
+
+	memstick_resume_host(msh);
+	return 0;
+}
+#endif /* CONFIG_PM_SLEEP */
+
+static int rtsx_usb_detect_ms_card(void *__host)
+{
+	struct rtsx_usb_ms *host = (struct rtsx_usb_ms *)__host;
+	struct rtsx_ucr *ucr = host->ucr;
+	u8 val = 0;
+	int err;
+
+	for (;;) {
+		mutex_lock(&ucr->dev_mutex);
+
+		/* Check pending MS card changes */
+		err = rtsx_usb_read_register(ucr, CARD_INT_PEND, &val);
+		if (err) {
+			mutex_unlock(&ucr->dev_mutex);
+			goto poll_again;
+		}
+
+		/* Clear the pending */
+		rtsx_usb_write_register(ucr, CARD_INT_PEND,
+				XD_INT | MS_INT | SD_INT,
+				XD_INT | MS_INT | SD_INT);
+
+		mutex_unlock(&ucr->dev_mutex);
+
+		if (val & MS_INT) {
+			dev_dbg(ms_dev(host), "MS slot change detected\n");
+			memstick_detect_change(host->msh);
+		}
+
+poll_again:
+		if (host->eject)
+			break;
+
+		msleep(1000);
+	}
+
+	complete(&host->detect_ms_exit);
+	return 0;
+}
+
+static int rtsx_usb_ms_drv_probe(struct platform_device *pdev)
+{
+	struct memstick_host *msh;
+	struct rtsx_usb_ms *host;
+	struct rtsx_ucr *ucr;
+	int err;
+
+	ucr = usb_get_intfdata(to_usb_interface(pdev->dev.parent));
+	if (!ucr)
+		return -ENXIO;
+
+	dev_dbg(&(pdev->dev),
+			"Realtek USB Memstick controller found\n");
+
+	msh = memstick_alloc_host(sizeof(*host), &pdev->dev);
+	if (!msh)
+		return -ENOMEM;
+
+	host = memstick_priv(msh);
+	host->ucr = ucr;
+	host->msh = msh;
+	host->pdev = pdev;
+	host->power_mode = MEMSTICK_POWER_OFF;
+	platform_set_drvdata(pdev, host);
+
+	mutex_init(&host->host_mutex);
+	INIT_WORK(&host->handle_req, rtsx_usb_ms_handle_req);
+
+	init_completion(&host->detect_ms_exit);
+	host->detect_ms = kthread_create(rtsx_usb_detect_ms_card, host,
+			"rtsx_usb_ms_%d", pdev->id);
+	if (IS_ERR(host->detect_ms)) {
+		dev_dbg(&(pdev->dev),
+				"Unable to create polling thread.\n");
+		err = PTR_ERR(host->detect_ms);
+		goto err_out;
+	}
+
+	msh->request = rtsx_usb_ms_request;
+	msh->set_param = rtsx_usb_ms_set_param;
+	msh->caps = MEMSTICK_CAP_PAR4;
+
+	pm_runtime_enable(&pdev->dev);
+	err = memstick_add_host(msh);
+	if (err)
+		goto err_out;
+
+	wake_up_process(host->detect_ms);
+	return 0;
+err_out:
+	memstick_free_host(msh);
+	return err;
+}
+
+static int rtsx_usb_ms_drv_remove(struct platform_device *pdev)
+{
+	struct rtsx_usb_ms *host = platform_get_drvdata(pdev);
+	struct memstick_host *msh;
+	int err;
+
+	if (!host)
+		return 0;
+
+	msh = host->msh;
+	host->eject = true;
+
+	mutex_lock(&host->host_mutex);
+	if (host->req) {
+		dev_dbg(&(pdev->dev),
+			"%s: Controller removed during transfer\n",
+			dev_name(&msh->dev));
+		host->req->error = -ENOMEDIUM;
+		do {
+			err = memstick_next_req(msh, &host->req);
+			if (!err)
+				host->req->error = -ENOMEDIUM;
+		} while (!err);
+	}
+	mutex_unlock(&host->host_mutex);
+
+	wait_for_completion(&host->detect_ms_exit);
+	memstick_remove_host(msh);
+	memstick_free_host(msh);
+
+	/* Balance possible unbalanced usage count
+	 * e.g. unconditional module removal
+	 */
+	if (pm_runtime_active(ms_dev(host)))
+		pm_runtime_put(ms_dev(host));
+
+	pm_runtime_disable(&pdev->dev);
+	platform_set_drvdata(pdev, NULL);
+
+	dev_dbg(&(pdev->dev),
+		": Realtek USB Memstick controller has been removed\n");
+
+	return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(rtsx_usb_ms_pm_ops,
+		rtsx_usb_ms_suspend, rtsx_usb_ms_resume);
+
+static struct platform_device_id rtsx_usb_ms_ids[] = {
+	{
+		.name = "rtsx_usb_ms",
+	}, {
+		/* sentinel */
+	}
+};
+MODULE_DEVICE_TABLE(platform, rtsx_usb_ms_ids);
+
+static struct platform_driver rtsx_usb_ms_driver = {
+	.probe		= rtsx_usb_ms_drv_probe,
+	.remove		= rtsx_usb_ms_drv_remove,
+	.id_table       = rtsx_usb_ms_ids,
+	.driver		= {
+		.owner	= THIS_MODULE,
+		.name	= "rtsx_usb_ms",
+		.pm	= &rtsx_usb_ms_pm_ops,
+	},
+};
+module_platform_driver(rtsx_usb_ms_driver);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Roger Tseng <[email protected]>");
+MODULE_DESCRIPTION("Realtek USB Memstick Card Host Driver");
#17 lore raw

Re: [PATCH v4 3/3] memstick: Add realtek USB memstick host driver

Quoted 6 lines · On Thu, 20 Mar 2014 16:38:03 +0800 Roger <[email protected]> wrote:
Quoted 5 lines · On 02/12/2014 06:00 PM, [email protected] wrote:

From: Roger Tseng <[email protected]>

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

Quoted 8 lines
Quoted 1 line

Andrew,

Would you please Ack or comment this patch(3/3) to let the 3 patches be merged together? I have been making the same request at the message thread of "[PATCH v4 2/3]" since several weeks ago but got no response. Thus I re-post here and hope I could get something.

Looks OK to me - I had a few minor quibbles. Please proceed in that way.

It would be nice if Alex and/or Maxim had time to look through the code.

#18 lore raw

Re: [PATCH v4 3/3] memstick: Add realtek USB memstick host driver

In reply to [email protected]
Quoted 15 lines · On Wed, 12 Feb 2014 18:00:38 +0800 <[email protected]> wrote:

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/rtsx_usb_ms.c new file +8 -0
+#include <linux/module.h>
+#include <linux/highmem.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+#include <linux/memstick.h>
+#include <linux/kthread.h>
+#include <linux/mfd/rtsx_usb.h>

drivers/memstick/host/rtsx_usb_ms.c line 38

Quoted 10 lines
drivers/memstick/host/rtsx_usb_ms.c new file +10 -0
+#include <linux/pm_runtime.h>
+#include <asm/unaligned.h>
+
+struct rtsx_usb_ms {
+	struct platform_device	*pdev;
+	struct rtsx_ucr	*ucr;
+	struct memstick_host	*msh;
+	struct memstick_request	*req;
+
+	struct mutex		host_mutex;

Should have included mutex.h.

drivers/memstick/host/rtsx_usb_ms.c line 41

Quoted 3 lines
drivers/memstick/host/rtsx_usb_ms.c new file +3 -0
+	struct work_struct	handle_req;
+
+	struct task_struct	*detect_ms;

sched.h.

drivers/memstick/host/rtsx_usb_ms.c line 42

Quoted 1 line
drivers/memstick/host/rtsx_usb_ms.c new file +1 -0
+	struct completion	detect_ms_exit;

completion.h.

Quoted 4 lines
drivers/memstick/host/rtsx_usb_ms.c new file +4 -0
+	u8			ssc_depth;
+	unsigned int		clock;
+	int			power_mode;
+	unsigned char           ifmode;

drivers/memstick/host/rtsx_usb_ms.c line 115

Quoted 10 lines
drivers/memstick/host/rtsx_usb_ms.c new file +7 -0
+	bool			eject;
+};
+
 
...
 
+
+#else
+
+#define ms_print_debug_regs(host)

static void ms_print_debug_regs(struct rtsx_usb_ms *host) {
}

It is good to have the same signature for either case. And doing it in C provides typechecking and can avoid variable-unused warnings.

Quoted 24 lines
drivers/memstick/host/rtsx_usb_ms.c new file +21 -0
+#endif
 
...
 
+static int ms_power_on(struct rtsx_usb_ms *host)
+{
+	struct rtsx_ucr *ucr = host->ucr;
+	int err;
+
+	dev_dbg(ms_dev(host), "%s\n", __func__);
+
+	rtsx_usb_init_cmd(ucr);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_SELECT, 0x07, MS_MOD_SEL);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_SHARE_MODE,
+			CARD_SHARE_MASK, CARD_SHARE_MS);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_EN,
+			MS_CLK_EN, MS_CLK_EN);
+	err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
+	if (err < 0)
+		return err;
+
+	if (CHECK_PKG(ucr, LQFP48))
+		err = ms_pull_ctl_enable_lqfp48(ucr);
+	else

drivers/memstick/host/rtsx_usb_ms.c line 203

Quoted 10 lines
drivers/memstick/host/rtsx_usb_ms.c new file +10 -0
+		err = ms_pull_ctl_enable_qfn24(ucr);
+	if (err < 0)
+		return err;
+
+	err = rtsx_usb_write_register(ucr, CARD_PWR_CTL,
+			POWER_MASK, PARTIAL_POWER_ON);
+	if (err)
+		return err;
+
+	/* Wait ms power stable */

Comment is strange.

Quoted 16 lines
drivers/memstick/host/rtsx_usb_ms.c new file +13 -0
+	usleep_range(800, 1000);
+
+	rtsx_usb_init_cmd(ucr);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
+			POWER_MASK, POWER_ON);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_OE,
+			MS_OUTPUT_EN, MS_OUTPUT_EN);
+
+	return rtsx_usb_send_cmd(ucr, MODE_C, 100);
+}
+
 
...
 
+static int ms_transfer_data(struct rtsx_usb_ms *host, unsigned char data_dir,
+		u8 tpc, u8 cfg, struct scatterlist *sg)

drivers/memstick/host/rtsx_usb_ms.c line 248

Quoted 10 lines
drivers/memstick/host/rtsx_usb_ms.c new file +10 -0
+{
+	struct rtsx_ucr *ucr = host->ucr;
+	int err;
+	unsigned int length = sg->length;
+	u16 sec_cnt = (u16)(length / 512);
+	u8 trans_mode, dma_dir, flag;
+	unsigned int pipe;
+	struct memstick_dev *card = host->msh->card;
+
+	dev_dbg(ms_dev(host), "%s: tpc = 0x%02x, data_dir = %s, length = %d\n",

length = %u

Quoted 74 lines
drivers/memstick/host/rtsx_usb_ms.c new file +74 -0
+			__func__, tpc, (data_dir == READ) ? "READ" : "WRITE",
+			length);
+
+	if (data_dir == READ) {
+		flag = MODE_CDIR;
+		dma_dir = DMA_DIR_FROM_CARD;
+		if (card->id.type != MEMSTICK_TYPE_PRO)
+			trans_mode = MS_TM_NORMAL_READ;
+		else
+			trans_mode = MS_TM_AUTO_READ;
+		pipe = usb_rcvbulkpipe(ucr->pusb_dev, EP_BULK_IN);
+	} else {
+		flag = MODE_CDOR;
+		dma_dir = DMA_DIR_TO_CARD;
+		if (card->id.type != MEMSTICK_TYPE_PRO)
+			trans_mode = MS_TM_NORMAL_WRITE;
+		else
+			trans_mode = MS_TM_AUTO_WRITE;
+		pipe = usb_sndbulkpipe(ucr->pusb_dev, EP_BULK_OUT);
+	}
+
+	rtsx_usb_init_cmd(ucr);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
+	if (card->id.type == MEMSTICK_TYPE_PRO) {
+		rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_SECTOR_CNT_H,
+				0xFF, (u8)(sec_cnt >> 8));
+		rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_SECTOR_CNT_L,
+				0xFF, (u8)sec_cnt);
+	}
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC3,
+			0xFF, (u8)(length >> 24));
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC2,
+			0xFF, (u8)(length >> 16));
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC1,
+			0xFF, (u8)(length >> 8));
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC0, 0xFF,
+			(u8)length);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_CTL,
+			0x03 | DMA_PACK_SIZE_MASK, dma_dir | DMA_EN | DMA_512);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
+			0x01, RING_BUFFER);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
+			0xFF, MS_TRANSFER_START | trans_mode);
+	rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
+			MS_TRANSFER_END, MS_TRANSFER_END);
+
+	err = rtsx_usb_send_cmd(ucr, flag | STAGE_MS_STATUS, 100);
+	if (err)
+		return err;
+
+	err = rtsx_usb_transfer_data(ucr, pipe, sg, length,
+			1, NULL, 10000);
+	if (err)
+		goto err_out;
+
+	err = rtsx_usb_get_rsp(ucr, 3, 15000);
+	if (err)
+		goto err_out;
+
+	if (ucr->rsp_buf[0] & MS_TRANSFER_ERR ||
+	    ucr->rsp_buf[1] & (MS_CRC16_ERR | MS_RDY_TIMEOUT)) {
+		err = -EIO;
+		goto err_out;
+	}
+	return 0;
+err_out:
+	ms_clear_error(host);
+	return err;
+}
+

drivers/memstick/host/rtsx_usb_ms.c line 332

Quoted 10 lines
drivers/memstick/host/rtsx_usb_ms.c new file +10 -0
+static int ms_write_bytes(struct rtsx_usb_ms *host, u8 tpc,
+		u8 cfg, u8 cnt, u8 *data, u8 *int_reg)
+{
+	struct rtsx_ucr *ucr = host->ucr;
+	int err, i;
+
+	dev_dbg(ms_dev(host), "%s: tpc = 0x%02x\n", __func__, tpc);
+
+	if (!data)
+		return -EINVAL;

Is this needed?

Quoted 60 lines
drivers/memstick/host/rtsx_usb_ms.c new file +59 -0
+	rtsx_usb_init_cmd(ucr);
+
+	for (i = 0; i < cnt; i++)
+		rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+				PPBUF_BASE2 + i, 0xFF, data[i]);
+
+	if (cnt % 2)
+		rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
+				PPBUF_BASE2 + i, 0xFF, 0xFF);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
+			0x01, PINGPONG_BUFFER);
+
+	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
+			0xFF, MS_TRANSFER_START | MS_TM_WRITE_BYTES);
+	rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
+			MS_TRANSFER_END, MS_TRANSFER_END);
+	rtsx_usb_add_cmd(ucr, READ_REG_CMD, MS_TRANS_CFG, 0, 0);
+
+	err = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
+	if (err)
+		return err;
+
+	err = rtsx_usb_get_rsp(ucr, 2, 5000);
+	if (err || (ucr->rsp_buf[0] & MS_TRANSFER_ERR)) {
+		u8 val;
+
+		rtsx_usb_ep0_read_register(ucr, MS_TRANS_CFG, &val);
+		dev_dbg(ms_dev(host), "MS_TRANS_CFG: 0x%02x\n", val);
+
+		if (int_reg)
+			*int_reg = val & 0x0F;
+
+		ms_print_debug_regs(host);
+
+		ms_clear_error(host);
+
+		if (!(tpc & 0x08)) {
+			if (val & MS_CRC16_ERR)
+				return -EIO;
+		} else {
+			if (!(val & 0x80)) {
+				if (val & (MS_INT_ERR | MS_INT_CMDNK))
+					return -EIO;
+			}
+		}
+
+		return -ETIMEDOUT;
+	}
+
+	if (int_reg)
+		*int_reg = ucr->rsp_buf[1] & 0x0F;
+
+	return 0;
+}
+
 

drivers/memstick/host/rtsx_usb_ms.c line 452

Quoted 10 lines
drivers/memstick/host/rtsx_usb_ms.c new file +8 -0
...
 
+static void rtsx_usb_ms_request(struct memstick_host *msh)
+{
+	struct rtsx_usb_ms *host = memstick_priv(msh);
+
+	dev_dbg(ms_dev(host), "--> %s\n", __func__);
+
+	schedule_work(&host->handle_req);
+}

I see a schedule_work() but I see no flush_scheduled_work() on the shutdown/rmmod path. Do we have races here? Should the shutdown paths be waiting for work completion before tearing things down?

Quoted 32 lines

...

drivers/memstick/host/rtsx_usb_ms.c new file +29 -0
+static int rtsx_usb_detect_ms_card(void *__host)
+{
+	struct rtsx_usb_ms *host = (struct rtsx_usb_ms *)__host;
+	struct rtsx_ucr *ucr = host->ucr;
+	u8 val = 0;
+	int err;
+
+	for (;;) {
+		mutex_lock(&ucr->dev_mutex);
+
+		/* Check pending MS card changes */
+		err = rtsx_usb_read_register(ucr, CARD_INT_PEND, &val);
+		if (err) {
+			mutex_unlock(&ucr->dev_mutex);
+			goto poll_again;
+		}
+
+		/* Clear the pending */
+		rtsx_usb_write_register(ucr, CARD_INT_PEND,
+				XD_INT | MS_INT | SD_INT,
+				XD_INT | MS_INT | SD_INT);
+
+		mutex_unlock(&ucr->dev_mutex);
+
+		if (val & MS_INT) {
+			dev_dbg(ms_dev(host), "MS slot change detected\n");
+			memstick_detect_change(host->msh);
+		}
+

drivers/memstick/host/rtsx_usb_ms.c line 709

Quoted 10 lines
drivers/memstick/host/rtsx_usb_ms.c new file +10 -0
+poll_again:
+		if (host->eject)
+			break;
+
+		msleep(1000);
+	}
+
+	complete(&host->detect_ms_exit);
+	return 0;
+}

Would be helpful to add a comment explaining that this is a kernel thread and describing its lifetime, exit conditions, etc.

Quoted 36 lines
drivers/memstick/host/rtsx_usb_ms.c new file +36 -0
+static int rtsx_usb_ms_drv_probe(struct platform_device *pdev)
+{
+	struct memstick_host *msh;
+	struct rtsx_usb_ms *host;
+	struct rtsx_ucr *ucr;
+	int err;
+
+	ucr = usb_get_intfdata(to_usb_interface(pdev->dev.parent));
+	if (!ucr)
+		return -ENXIO;
+
+	dev_dbg(&(pdev->dev),
+			"Realtek USB Memstick controller found\n");
+
+	msh = memstick_alloc_host(sizeof(*host), &pdev->dev);
+	if (!msh)
+		return -ENOMEM;
+
+	host = memstick_priv(msh);
+	host->ucr = ucr;
+	host->msh = msh;
+	host->pdev = pdev;
+	host->power_mode = MEMSTICK_POWER_OFF;
+	platform_set_drvdata(pdev, host);
+
+	mutex_init(&host->host_mutex);
+	INIT_WORK(&host->handle_req, rtsx_usb_ms_handle_req);
+
+	init_completion(&host->detect_ms_exit);
+	host->detect_ms = kthread_create(rtsx_usb_detect_ms_card, host,
+			"rtsx_usb_ms_%d", pdev->id);
+	if (IS_ERR(host->detect_ms)) {
+		dev_dbg(&(pdev->dev),
+				"Unable to create polling thread.\n");
+		err = PTR_ERR(host->detect_ms);
+		goto err_out;

drivers/memstick/host/rtsx_usb_ms.c line 756

Quoted 10 lines
drivers/memstick/host/rtsx_usb_ms.c new file +10 -0
+	}
+
+	msh->request = rtsx_usb_ms_request;
+	msh->set_param = rtsx_usb_ms_set_param;
+	msh->caps = MEMSTICK_CAP_PAR4;
+
+	pm_runtime_enable(&pdev->dev);
+	err = memstick_add_host(msh);
+	if (err)
+		goto err_out;

Isn't that kernel thread still running?

Quoted 5 lines
drivers/memstick/host/rtsx_usb_ms.c new file +5 -0
+	wake_up_process(host->detect_ms);
+	return 0;
+err_out:
+	memstick_free_host(msh);
+	return err;

drivers/memstick/host/rtsx_usb_ms.c line 772

Quoted 10 lines
drivers/memstick/host/rtsx_usb_ms.c new file +10 -0
+}
+
+static int rtsx_usb_ms_drv_remove(struct platform_device *pdev)
+{
+	struct rtsx_usb_ms *host = platform_get_drvdata(pdev);
+	struct memstick_host *msh;
+	int err;
+
+	if (!host)
+		return 0;

Can this happen?

Quoted 8 lines
drivers/memstick/host/rtsx_usb_ms.c new file +8 -0
+	msh = host->msh;
+	host->eject = true;
+
+	mutex_lock(&host->host_mutex);
+	if (host->req) {
+		dev_dbg(&(pdev->dev),
+			"%s: Controller removed during transfer\n",
+			dev_name(&msh->dev));

drivers/memstick/host/rtsx_usb_ms.c line 791

Quoted 10 lines
drivers/memstick/host/rtsx_usb_ms.c new file +10 -0
+		host->req->error = -ENOMEDIUM;
+		do {
+			err = memstick_next_req(msh, &host->req);
+			if (!err)
+				host->req->error = -ENOMEDIUM;
+		} while (!err);
+	}
+	mutex_unlock(&host->host_mutex);
+
+	wait_for_completion(&host->detect_ms_exit);

OK, so here we're waiting for the kernel thread to terminate.

Quoted 20 lines
drivers/memstick/host/rtsx_usb_ms.c new file +17 -0
+	memstick_remove_host(msh);
+	memstick_free_host(msh);
+
+	/* Balance possible unbalanced usage count
+	 * e.g. unconditional module removal
+	 */
+	if (pm_runtime_active(ms_dev(host)))
+		pm_runtime_put(ms_dev(host));
+
+	pm_runtime_disable(&pdev->dev);
+	platform_set_drvdata(pdev, NULL);
+
+	dev_dbg(&(pdev->dev),
+		": Realtek USB Memstick controller has been removed\n");
+
+	return 0;
+}
 
...
author
#19 lore raw

Re: [PATCH v4 3/3] memstick: Add realtek USB memstick host driver

Quoted 7 lines · Andrew Morton
Quoted 5 lines · On Wed, 12 Feb 2014 18:00:38 +0800 <[email protected]> wrote:

From: Roger Tseng <[email protected]>

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

...

Quoted 40 lines
Quoted 40 lines
drivers/memstick/host/rtsx_usb_ms.c new file +40 -0
+static int rtsx_usb_ms_drv_probe(struct platform_device *pdev)
+{
+	struct memstick_host *msh;
+	struct rtsx_usb_ms *host;
+	struct rtsx_ucr *ucr;
+	int err;
+
+	ucr = usb_get_intfdata(to_usb_interface(pdev->dev.parent));
+	if (!ucr)
+		return -ENXIO;
+
+	dev_dbg(&(pdev->dev),
+			"Realtek USB Memstick controller found\n");
+
+	msh = memstick_alloc_host(sizeof(*host), &pdev->dev);
+	if (!msh)
+		return -ENOMEM;
+
+	host = memstick_priv(msh);
+	host->ucr = ucr;
+	host->msh = msh;
+	host->pdev = pdev;
+	host->power_mode = MEMSTICK_POWER_OFF;
+	platform_set_drvdata(pdev, host);
+
+	mutex_init(&host->host_mutex);
+	INIT_WORK(&host->handle_req, rtsx_usb_ms_handle_req);
+
+	init_completion(&host->detect_ms_exit);
+	host->detect_ms = kthread_create(rtsx_usb_detect_ms_card, host,
+			"rtsx_usb_ms_%d", pdev->id);
+	if (IS_ERR(host->detect_ms)) {
+		dev_dbg(&(pdev->dev),
+				"Unable to create polling thread.\n");
+		err = PTR_ERR(host->detect_ms);
+		goto err_out;
+	}
+
+	msh->request = rtsx_usb_ms_request;
+	msh->set_param = rtsx_usb_ms_set_param;
Quoted 9 lines

drivers/memstick/host/rtsx_usb_ms.c line 756

Quoted 6 lines
drivers/memstick/host/rtsx_usb_ms.c new file +6 -0
+	msh->caps = MEMSTICK_CAP_PAR4;
+
+	pm_runtime_enable(&pdev->dev);
+	err = memstick_add_host(msh);
+	if (err)
+		goto err_out;

Isn't that kernel thread still running?

The kernel thread is created(kthread_create) but should not start before the "goto".

Did I miss anything or will it be better to move all kthread things after here?

Quoted 6 lines

drivers/memstick/host/rtsx_usb_ms.c line 763

Quoted 6 lines
drivers/memstick/host/rtsx_usb_ms.c new file +6 -0
+	wake_up_process(host->detect_ms);
+	return 0;
+err_out:
+	memstick_free_host(msh);
+	return err;
+}

Best regards,
Roger Tseng