2008-12-12 13:58:53 +02:00
|
|
|
|
From f4ae4d14785cce7635c750286e579e79c3a27a7a Mon Sep 17 00:00:00 2001
|
2008-12-12 02:02:36 +02:00
|
|
|
|
From: mokopatches <mokopatches@openmoko.org>
|
2008-12-12 13:58:53 +02:00
|
|
|
|
Date: Sun, 13 Apr 2008 07:23:57 +0100
|
2008-12-12 02:02:36 +02:00
|
|
|
|
Subject: [PATCH] atheros_2_0_sdio_stack.patch
|
|
|
|
|
|
|
|
|
|
|
|
---
|
|
|
|
|
|
arch/arm/Kconfig | 2 +
|
|
|
|
|
|
drivers/Kconfig | 2 +
|
|
|
|
|
|
drivers/Makefile | 1 +
|
|
|
|
|
|
drivers/sdio/Kconfig | 17 +
|
|
|
|
|
|
drivers/sdio/Makefile | 4 +
|
|
|
|
|
|
drivers/sdio/stack/Makefile | 1 +
|
|
|
|
|
|
drivers/sdio/stack/busdriver/Makefile | 2 +
|
|
|
|
|
|
drivers/sdio/stack/busdriver/_busdriver.h | 466 ++++
|
|
|
|
|
|
drivers/sdio/stack/busdriver/sdio_bus.c | 2120 +++++++++++++++
|
|
|
|
|
|
drivers/sdio/stack/busdriver/sdio_bus_events.c | 1040 +++++++
|
|
|
|
|
|
drivers/sdio/stack/busdriver/sdio_bus_misc.c | 3122 ++++++++++++++++++++++
|
|
|
|
|
|
drivers/sdio/stack/busdriver/sdio_bus_os.c | 832 ++++++
|
|
|
|
|
|
drivers/sdio/stack/busdriver/sdio_function.c | 715 +++++
|
|
|
|
|
|
drivers/sdio/stack/lib/Makefile | 2 +
|
|
|
|
|
|
drivers/sdio/stack/lib/_sdio_lib.h | 50 +
|
|
|
|
|
|
drivers/sdio/stack/lib/sdio_lib_c.c | 908 +++++++
|
|
|
|
|
|
drivers/sdio/stack/lib/sdio_lib_os.c | 251 ++
|
|
|
|
|
|
drivers/sdio/stack/platform/Makefile | 2 +
|
|
|
|
|
|
drivers/sdio/stack/platform/sdioplatformdriver.c | 300 +++
|
|
|
|
|
|
include/linux/sdio/_sdio_defs.h | 638 +++++
|
|
|
|
|
|
include/linux/sdio/ctsystem.h | 115 +
|
|
|
|
|
|
include/linux/sdio/ctsystem_linux.h | 983 +++++++
|
|
|
|
|
|
include/linux/sdio/mmc_defs.h | 103 +
|
|
|
|
|
|
include/linux/sdio/sdio_busdriver.h | 1435 ++++++++++
|
|
|
|
|
|
include/linux/sdio/sdio_hcd_defs.h | 219 ++
|
|
|
|
|
|
include/linux/sdio/sdio_lib.h | 270 ++
|
|
|
|
|
|
include/linux/sdio/sdlist.h | 141 +
|
|
|
|
|
|
27 files changed, 13741 insertions(+), 0 deletions(-)
|
|
|
|
|
|
create mode 100644 drivers/sdio/Kconfig
|
|
|
|
|
|
create mode 100644 drivers/sdio/Makefile
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/Makefile
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/busdriver/Makefile
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/busdriver/_busdriver.h
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/busdriver/sdio_bus.c
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/busdriver/sdio_bus_events.c
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/busdriver/sdio_bus_misc.c
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/busdriver/sdio_bus_os.c
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/busdriver/sdio_function.c
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/lib/Makefile
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/lib/_sdio_lib.h
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/lib/sdio_lib_c.c
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/lib/sdio_lib_os.c
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/platform/Makefile
|
|
|
|
|
|
create mode 100644 drivers/sdio/stack/platform/sdioplatformdriver.c
|
|
|
|
|
|
create mode 100644 include/linux/sdio/_sdio_defs.h
|
|
|
|
|
|
create mode 100644 include/linux/sdio/ctsystem.h
|
|
|
|
|
|
create mode 100644 include/linux/sdio/ctsystem_linux.h
|
|
|
|
|
|
create mode 100644 include/linux/sdio/mmc_defs.h
|
|
|
|
|
|
create mode 100644 include/linux/sdio/sdio_busdriver.h
|
|
|
|
|
|
create mode 100644 include/linux/sdio/sdio_hcd_defs.h
|
|
|
|
|
|
create mode 100644 include/linux/sdio/sdio_lib.h
|
|
|
|
|
|
create mode 100644 include/linux/sdio/sdlist.h
|
|
|
|
|
|
|
|
|
|
|
|
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
|
2008-12-12 13:58:53 +02:00
|
|
|
|
index a04f507..23e3d6b 100644
|
2008-12-12 02:02:36 +02:00
|
|
|
|
--- a/arch/arm/Kconfig
|
|
|
|
|
|
+++ b/arch/arm/Kconfig
|
2008-12-12 13:58:53 +02:00
|
|
|
|
@@ -1064,6 +1064,8 @@ source "drivers/hid/Kconfig"
|
2008-12-12 02:02:36 +02:00
|
|
|
|
|
|
|
|
|
|
source "drivers/usb/Kconfig"
|
|
|
|
|
|
|
|
|
|
|
|
+source "drivers/sdio/Kconfig"
|
|
|
|
|
|
+
|
|
|
|
|
|
source "drivers/mmc/Kconfig"
|
|
|
|
|
|
|
|
|
|
|
|
source "drivers/leds/Kconfig"
|
|
|
|
|
|
diff --git a/drivers/Kconfig b/drivers/Kconfig
|
2008-12-12 13:58:53 +02:00
|
|
|
|
index f4076d9..bea3e95 100644
|
2008-12-12 02:02:36 +02:00
|
|
|
|
--- a/drivers/Kconfig
|
|
|
|
|
|
+++ b/drivers/Kconfig
|
2008-12-12 13:58:53 +02:00
|
|
|
|
@@ -74,6 +74,8 @@ source "drivers/hid/Kconfig"
|
2008-12-12 02:02:36 +02:00
|
|
|
|
|
|
|
|
|
|
source "drivers/usb/Kconfig"
|
|
|
|
|
|
|
|
|
|
|
|
+source "drivers/sdio/Kconfig"
|
|
|
|
|
|
+
|
|
|
|
|
|
source "drivers/mmc/Kconfig"
|
|
|
|
|
|
|
2008-12-12 13:58:53 +02:00
|
|
|
|
source "drivers/leds/Kconfig"
|
2008-12-12 02:02:36 +02:00
|
|
|
|
diff --git a/drivers/Makefile b/drivers/Makefile
|
2008-12-12 13:58:53 +02:00
|
|
|
|
index 8cb37e3..7951916 100644
|
2008-12-12 02:02:36 +02:00
|
|
|
|
--- a/drivers/Makefile
|
|
|
|
|
|
+++ b/drivers/Makefile
|
2008-12-12 13:58:53 +02:00
|
|
|
|
@@ -77,6 +77,7 @@ obj-$(CONFIG_LGUEST_GUEST) += lguest/
|
|
|
|
|
|
obj-$(CONFIG_CPU_FREQ) += cpufreq/
|
2008-12-12 02:02:36 +02:00
|
|
|
|
obj-$(CONFIG_CPU_IDLE) += cpuidle/
|
|
|
|
|
|
obj-$(CONFIG_MMC) += mmc/
|
|
|
|
|
|
+obj-$(CONFIG_SDIO) += sdio/
|
|
|
|
|
|
obj-$(CONFIG_NEW_LEDS) += leds/
|
|
|
|
|
|
obj-$(CONFIG_INFINIBAND) += infiniband/
|
|
|
|
|
|
obj-$(CONFIG_SGI_SN) += sn/
|
|
|
|
|
|
diff --git a/drivers/sdio/Kconfig b/drivers/sdio/Kconfig
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..14bf5e3
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/Kconfig
|
|
|
|
|
|
@@ -0,0 +1,17 @@
|
|
|
|
|
|
+#
|
|
|
|
|
|
+# SDIO driver and host controller support
|
|
|
|
|
|
+#
|
|
|
|
|
|
+
|
|
|
|
|
|
+menu "SDIO support"
|
|
|
|
|
|
+
|
|
|
|
|
|
+config SDIO
|
|
|
|
|
|
+ tristate "SDIO support"
|
|
|
|
|
|
+ default m
|
|
|
|
|
|
+ ---help---
|
|
|
|
|
|
+ good luck.
|
|
|
|
|
|
+
|
|
|
|
|
|
+source "drivers/sdio/hcd/Kconfig"
|
|
|
|
|
|
+
|
|
|
|
|
|
+source "drivers/sdio/function/Kconfig"
|
|
|
|
|
|
+
|
|
|
|
|
|
+endmenu
|
|
|
|
|
|
diff --git a/drivers/sdio/Makefile b/drivers/sdio/Makefile
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..f56aa0f
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/Makefile
|
|
|
|
|
|
@@ -0,0 +1,4 @@
|
|
|
|
|
|
+#Makefile for SDIO stack
|
|
|
|
|
|
+obj-$(CONFIG_SDIO) += stack/
|
|
|
|
|
|
+obj-$(CONFIG_SDIO) += hcd/
|
|
|
|
|
|
+obj-$(CONFIG_SDIO) += function/
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/Makefile b/drivers/sdio/stack/Makefile
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..ff0e24d
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/Makefile
|
|
|
|
|
|
@@ -0,0 +1 @@
|
|
|
|
|
|
+obj-$(CONFIG_SDIO) += busdriver/ lib/
|
|
|
|
|
|
\ No newline at end of file
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/busdriver/Makefile b/drivers/sdio/stack/busdriver/Makefile
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..1130e2d
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/busdriver/Makefile
|
|
|
|
|
|
@@ -0,0 +1,2 @@
|
|
|
|
|
|
+obj-$(CONFIG_SDIO) += sdio_busdriver.o
|
|
|
|
|
|
+sdio_busdriver-objs := sdio_bus.o sdio_function.o sdio_bus_misc.o sdio_bus_events.o sdio_bus_os.o
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/busdriver/_busdriver.h b/drivers/sdio/stack/busdriver/_busdriver.h
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..a85aed1
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/busdriver/_busdriver.h
|
|
|
|
|
|
@@ -0,0 +1,466 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: _busdriver.h
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: internal include file for busdriver
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#ifndef ___BUSDRIVER_H___
|
|
|
|
|
|
+#define ___BUSDRIVER_H___
|
|
|
|
|
|
+#include <linux/sdio/sdio_lib.h>
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDIODBG_FUNC_IRQ (SDDBG_TRACE + 1)
|
|
|
|
|
|
+#define SDIODBG_REQUESTS (SDDBG_TRACE + 2)
|
|
|
|
|
|
+#define SDIODBG_CD_TIMER (SDDBG_TRACE + 3)
|
|
|
|
|
|
+#define SDIODBG_HCD_EVENTS (SDDBG_TRACE + 4)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDIOBUS_CD_TIMER_ID 0
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDBUS_MAX_RETRY 3
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* Notes on list linkages:
|
|
|
|
|
|
+ * list heads are held in BDCONTEXT
|
|
|
|
|
|
+ * HcdList - SDHCD
|
|
|
|
|
|
+ * one per registered host controller
|
|
|
|
|
|
+ * Next - links of all HCDs
|
|
|
|
|
|
+ * DeviceList SDDEVICE
|
|
|
|
|
|
+ * one per inserted device
|
|
|
|
|
|
+ * Next - links of all devices
|
|
|
|
|
|
+ * DeviceListNext - links of all devices on a function
|
|
|
|
|
|
+ * pFunction - ptr to Function supportting this device
|
|
|
|
|
|
+ * pHcd - ptr to HCD with supporting this device
|
|
|
|
|
|
+ * FunctionList SDFUNCTION
|
|
|
|
|
|
+ * one per register function driver
|
|
|
|
|
|
+ * Next - links of all functions
|
|
|
|
|
|
+ * DeviceList - list of devices being support by this function
|
|
|
|
|
|
+ * uses DeviceListNext in SDDEVICE to link
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDMMC_DEFAULT_CMD_RETRIES 1
|
|
|
|
|
|
+#define SDMMC_DEFAULT_CARD_READY_RETRIES 200
|
|
|
|
|
|
+#define OCR_READY_CHECK_DELAY_MS 10
|
|
|
|
|
|
+#define SDMMC_POWER_SETTLE_DELAY 400 /* in milliseconds */
|
|
|
|
|
|
+#define SDBUS_DEFAULT_REQ_LIST_SIZE 16
|
|
|
|
|
|
+#define SDBUS_DEFAULT_REQ_SIG_SIZE 8
|
|
|
|
|
|
+#define CARD_DETECT_PAUSE 100
|
|
|
|
|
|
+#define SDBUS_DEFAULT_CD_POLLING_INTERVAL 1000 /* in milliseconds */
|
|
|
|
|
|
+#define MAX_CARD_DETECT_MSGS 16
|
|
|
|
|
|
+#define SDMMC_DEFAULT_BYTES_PER_BLOCK 2048
|
|
|
|
|
|
+#define SDMMC_DEFAULT_BLOCKS_PER_TRANS 512
|
|
|
|
|
|
+#define SDMMC_CMD13_POLLING_MULTIPLIER 1000 /* per block multiplier */
|
|
|
|
|
|
+#define MAX_HCD_REQ_RECURSION 5
|
|
|
|
|
|
+#define MAX_HCD_RECURSION_RUNAWAY 100
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* internal signalling item */
|
|
|
|
|
|
+typedef struct _SIGNAL_ITEM{
|
|
|
|
|
|
+ SDLIST SDList; /* list link*/
|
|
|
|
|
|
+ OS_SIGNAL Signal; /* signal */
|
|
|
|
|
|
+}SIGNAL_ITEM, *PSIGNAL_ITEM;
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef struct _HCD_EVENT_MESSAGE {
|
|
|
|
|
|
+ HCD_EVENT Event; /* the event */
|
|
|
|
|
|
+ PSDHCD pHcd; /* hcd that generated the event */
|
|
|
|
|
|
+}HCD_EVENT_MESSAGE, *PHCD_EVENT_MESSAGE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* internal data for bus driver */
|
|
|
|
|
|
+typedef struct _BDCONTEXT {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* list of SD requests and signalling semaphores and a semaphore to protect it */
|
|
|
|
|
|
+ SDLIST RequestList;
|
|
|
|
|
|
+ SDLIST SignalList;
|
|
|
|
|
|
+ OS_CRITICALSECTION RequestListCritSection;
|
|
|
|
|
|
+ /* list of host controller bus drivers, sempahore to protect it */
|
|
|
|
|
|
+ SDLIST HcdList;
|
|
|
|
|
|
+ OS_SEMAPHORE HcdListSem;
|
|
|
|
|
|
+ /* list of inserted devices, semaphore to protect it */
|
|
|
|
|
|
+ SDLIST DeviceList;
|
|
|
|
|
|
+ OS_SEMAPHORE DeviceListSem;
|
|
|
|
|
|
+ /* list of function drivers, semaphore to protect it */
|
|
|
|
|
|
+ SDLIST FunctionList;
|
|
|
|
|
|
+ OS_SEMAPHORE FunctionListSem;
|
|
|
|
|
|
+ INT RequestListSize; /* default request list */
|
|
|
|
|
|
+ INT SignalSemListSize; /* default signalling semaphore size */
|
|
|
|
|
|
+ INT CurrentRequestAllocations; /*current count of allocated requests */
|
|
|
|
|
|
+ INT CurrentSignalAllocations; /* current count of signal allocations */
|
|
|
|
|
|
+ INT MaxRequestAllocations; /* max number of allocated requests to keep around*/
|
|
|
|
|
|
+ INT MaxSignalAllocations; /* max number of signal allocations to keep around*/
|
|
|
|
|
|
+ INT RequestRetries; /* cmd retries */
|
|
|
|
|
|
+ INT CardReadyPollingRetry; /* card ready polling retry count */
|
|
|
|
|
|
+ INT PowerSettleDelay; /* power settle delay */
|
|
|
|
|
|
+ INT CMD13PollingMultiplier; /* CMD13 (GET STATUS) multiplier */
|
|
|
|
|
|
+ SD_BUSCLOCK_RATE DefaultOperClock; /* default operation clock */
|
|
|
|
|
|
+ SD_BUSMODE_FLAGS DefaultBusMode; /* default bus mode */
|
|
|
|
|
|
+ UINT16 DefaultOperBlockLen; /* default operational block length per block */
|
|
|
|
|
|
+ UINT16 DefaultOperBlockCount; /* default operational block count per transaction */
|
|
|
|
|
|
+ UINT32 CDPollingInterval; /* card insert/removal polling interval */
|
|
|
|
|
|
+ UINT8 InitMask; /* bus driver init mask */
|
|
|
|
|
|
+#define BD_TIMER_INIT 0x01
|
|
|
|
|
|
+#define HELPER_INIT 0x02
|
|
|
|
|
|
+#define RESOURCE_INIT 0x04
|
|
|
|
|
|
+ BOOL CDTimerQueued; /* card detect timer queued */
|
|
|
|
|
|
+ OSKERNEL_HELPER CardDetectHelper; /* card detect helper */
|
|
|
|
|
|
+ PSDMESSAGE_QUEUE pCardDetectMsgQueue; /* card detect message queue */
|
|
|
|
|
|
+ ULONG HcdInUseField; /* bit field of in use HCD numbers*/
|
|
|
|
|
|
+ UINT32 ConfigFlags; /* bus driver configuration flags */
|
|
|
|
|
|
+#define BD_CONFIG_SDREQ_FORCE_ALL_ASYNC 0x00000001
|
|
|
|
|
|
+ INT MaxHcdRecursion; /* max HCD recurion level */
|
|
|
|
|
|
+}BDCONTEXT, *PBDCONTEXT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define BD_DEFAULT_CONFIG_FLAGS 0x00000000
|
|
|
|
|
|
+#define IsQueueBusy(pRequestQueue) (pRequestQueue)->Busy
|
|
|
|
|
|
+#define MarkQueueBusy(pRequestQueue) (pRequestQueue)->Busy = TRUE
|
|
|
|
|
|
+#define MarkQueueNotBusy(pRequestQueue) (pRequestQueue)->Busy = FALSE
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define CLEAR_INTERNAL_REQ_FLAGS(pReq) (pReq)->Flags &= ~(UINT)((SDREQ_FLAGS_RESP_SPI_CONVERTED | \
|
|
|
|
|
|
+ SDREQ_FLAGS_FORCE_DEFERRED_COMPLETE))
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* macros to insert request into the queue */
|
|
|
|
|
|
+#define QueueRequest(pReqQ,pReq) SDListInsertTail(&(pReqQ)->Queue,&(pReq)->SDList)
|
|
|
|
|
|
+#define QueueRequestToFront(pReqQ,pReq) SDListInsertHead(&(pReqQ)->Queue,&(pReq)->SDList)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* macros to remove an item from the head of the queue */
|
|
|
|
|
|
+static INLINE PSDREQUEST DequeueRequest(PSDREQUESTQUEUE pRequestQueue) {
|
|
|
|
|
|
+ PSDLIST pItem;
|
|
|
|
|
|
+ pItem = SDListRemoveItemFromHead(&pRequestQueue->Queue);
|
|
|
|
|
|
+ if (pItem != NULL) {
|
|
|
|
|
|
+ return CONTAINING_STRUCT(pItem, SDREQUEST, SDList);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return NULL;
|
|
|
|
|
|
+};
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE SDIO_STATUS InitializeRequestQueue(PSDREQUESTQUEUE pRequestQueue) {
|
|
|
|
|
|
+ SDLIST_INIT(&pRequestQueue->Queue);
|
|
|
|
|
|
+ MarkQueueNotBusy(pRequestQueue);
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE void CleanupRequestQueue(PSDREQUESTQUEUE pRequestQueue) {
|
|
|
|
|
|
+
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* for bus driver internal use only */
|
|
|
|
|
|
+SDIO_STATUS _SDIO_BusDriverInitialize(void);
|
|
|
|
|
|
+SDIO_STATUS _SDIO_BusGetDefaultSettings(PBDCONTEXT pBdc);
|
|
|
|
|
|
+void _SDIO_BusDriverCleanup(void);
|
|
|
|
|
|
+SDIO_STATUS RemoveAllFunctions(void);
|
|
|
|
|
|
+SDIO_STATUS RemoveHcdFunctions(PSDHCD pHcd);
|
|
|
|
|
|
+PSDDEVICE AllocateDevice(PSDHCD pHcd);
|
|
|
|
|
|
+BOOL AddDeviceToList(PSDDEVICE pDevice);
|
|
|
|
|
|
+SDIO_STATUS DeleteDevices(PSDHCD pHcd);
|
|
|
|
|
|
+SDIO_STATUS NotifyDeviceRemove(PSDDEVICE pDevice);
|
|
|
|
|
|
+extern PBDCONTEXT pBusContext;
|
|
|
|
|
|
+extern const CT_VERSION_CODE g_Version;
|
|
|
|
|
|
+SDIO_STATUS _SDIO_RegisterHostController(PSDHCD pHcd);
|
|
|
|
|
|
+SDIO_STATUS _SDIO_UnregisterHostController(PSDHCD pHcd);
|
|
|
|
|
|
+SDIO_STATUS _SDIO_HandleHcdEvent(PSDHCD pHcd, HCD_EVENT Event);
|
|
|
|
|
|
+SDIO_STATUS _SDIO_RegisterFunction(PSDFUNCTION pFunction);
|
|
|
|
|
|
+SDIO_STATUS _SDIO_UnregisterFunction(PSDFUNCTION pFunction);
|
|
|
|
|
|
+SDIO_STATUS _SDIO_CheckResponse(PSDHCD pHcd, PSDREQUEST pReq, SDHCD_RESPONSE_CHECK_MODE CheckMode);
|
|
|
|
|
|
+SDIO_STATUS ProbeForFunction(PSDDEVICE pDevice, PSDHCD pHcd);
|
|
|
|
|
|
+SDIO_STATUS SDInitializeCard(PSDHCD pHcd);
|
|
|
|
|
|
+SDIO_STATUS SDQuerySDMMCInfo(PSDDEVICE pDevice);
|
|
|
|
|
|
+SDIO_STATUS SDQuerySDIOInfo(PSDDEVICE pDevice);
|
|
|
|
|
|
+SDIO_STATUS SDEnableFunction(PSDDEVICE pDevice, PSDCONFIG_FUNC_ENABLE_DISABLE_DATA pEnData);
|
|
|
|
|
|
+SDIO_STATUS SDAllocFreeSlotCurrent(PSDDEVICE pDevice, BOOL Allocate, PSDCONFIG_FUNC_SLOT_CURRENT_DATA pData);
|
|
|
|
|
|
+SDIO_STATUS SDMaskUnmaskFunctionIRQ(PSDDEVICE pDevice, BOOL Mask);
|
|
|
|
|
|
+SDIO_STATUS SDFunctionAckInterrupt(PSDDEVICE pDevice);
|
|
|
|
|
|
+SDIO_STATUS SDSPIModeEnableDisableCRC(PSDDEVICE pDevice,BOOL Enable);
|
|
|
|
|
|
+SDIO_STATUS IssueBusConfig(PSDDEVICE pDev, PSDCONFIG pConfig);
|
|
|
|
|
|
+SDIO_STATUS IssueBusRequest(PSDDEVICE pDev, PSDREQUEST pReq);
|
|
|
|
|
|
+PSDREQUEST IssueAllocRequest(PSDDEVICE pDev);
|
|
|
|
|
|
+void IssueFreeRequest(PSDDEVICE pDev, PSDREQUEST pReq);
|
|
|
|
|
|
+PSDREQUEST AllocateRequest(void);
|
|
|
|
|
|
+void FreeRequest(PSDREQUEST pReq);
|
|
|
|
|
|
+PSIGNAL_ITEM AllocateSignal(void);
|
|
|
|
|
|
+void FreeSignal(PSIGNAL_ITEM pSignal);
|
|
|
|
|
|
+SDIO_STATUS InitializeTimers(void);
|
|
|
|
|
|
+SDIO_STATUS CleanupTimers(void);
|
|
|
|
|
|
+SDIO_STATUS QueueTimer(INT TimerID, UINT32 TimeOut);
|
|
|
|
|
|
+SDIO_STATUS DeviceAttach(PSDHCD pHcd);
|
|
|
|
|
|
+SDIO_STATUS DeviceDetach(PSDHCD pHcd);
|
|
|
|
|
|
+SDIO_STATUS DeviceInterrupt(PSDHCD pHcd);
|
|
|
|
|
|
+SDIO_STATUS CardInitSetup(PSDHCD pHcd);
|
|
|
|
|
|
+void RunCardDetect(void);
|
|
|
|
|
|
+void SDIO_NotifyTimerTriggered(INT TimerID);
|
|
|
|
|
|
+SDIO_STATUS TestPresence(PSDHCD pHcd,
|
|
|
|
|
|
+ CARD_INFO_FLAGS TestType,
|
|
|
|
|
|
+ PSDREQUEST pReq);
|
|
|
|
|
|
+#define _IssueSimpleBusRequest(pHcd,Cmd,Arg,Flags,pReqToUse) \
|
|
|
|
|
|
+ _IssueBusRequestBd((pHcd),(Cmd),(Arg),(Flags),(pReqToUse),NULL,0)
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS Do_OS_IncHcdReference(PSDHCD pHcd);
|
|
|
|
|
|
+SDIO_STATUS Do_OS_DecHcdReference(PSDHCD pHcd);
|
|
|
|
|
|
+SDIO_STATUS TryNoIrqPendingCheck(PSDDEVICE pDev);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check API version compatibility of an HCD or function driver to a stack major/minor version
|
|
|
|
|
|
+ if the driver version is greater than the major number, we are compatible
|
|
|
|
|
|
+ if the driver version is equal, then we check if the minor is greater than or equal
|
|
|
|
|
|
+ we don't have to check for the less than major, because the bus driver never loads
|
|
|
|
|
|
+ drivers with different major numbers ...
|
|
|
|
|
|
+ if the busdriver compiled version major is greater than the major version being checked this
|
|
|
|
|
|
+ macro will resolved to ALWAYS true thus optimizing the code to not check the HCD since
|
|
|
|
|
|
+ as a rule we never load an HCD with a lower major number */
|
|
|
|
|
|
+#define CHECK_API_VERSION_COMPAT(p,major,minor) \
|
|
|
|
|
|
+ ((CT_SDIO_STACK_VERSION_MAJOR(CT_SDIO_STACK_VERSION_CODE) > (major)) || \
|
|
|
|
|
|
+ (GET_SDIO_STACK_VERSION_MINOR((p)) >= (minor)))
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE SDIO_STATUS OS_IncHcdReference(PSDHCD pHcd) {
|
|
|
|
|
|
+ /* this API was added in version 2.3 which requires access to a field in the HCD structure */
|
|
|
|
|
|
+ if (CHECK_API_VERSION_COMPAT(pHcd,2,3)) {
|
|
|
|
|
|
+ /* we can safely call the OS-dependent function */
|
|
|
|
|
|
+ return Do_OS_IncHcdReference(pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE SDIO_STATUS OS_DecHcdReference(PSDHCD pHcd) {
|
|
|
|
|
|
+ /* this API was added in version 2.3 which requires access to a field in the HCD structure */
|
|
|
|
|
|
+ if (CHECK_API_VERSION_COMPAT(pHcd,2,3)) {
|
|
|
|
|
|
+ /* we can safely call the OS-dependent function */
|
|
|
|
|
|
+ return Do_OS_DecHcdReference(pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS _IssueBusRequestBd(PSDHCD pHcd,
|
|
|
|
|
|
+ UINT8 Cmd,
|
|
|
|
|
|
+ UINT32 Argument,
|
|
|
|
|
|
+ SDREQUEST_FLAGS Flags,
|
|
|
|
|
|
+ PSDREQUEST pReqToUse,
|
|
|
|
|
|
+ PVOID pData,
|
|
|
|
|
|
+ INT Length);
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS IssueRequestToHCD(PSDHCD pHcd,PSDREQUEST pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define CALL_HCD_CONFIG(pHcd,pCfg) (pHcd)->pConfigure((pHcd),(pCfg))
|
|
|
|
|
|
+ /* macro to force all requests to be asynchronous in the HCD */
|
|
|
|
|
|
+static INLINE BOOL ForceAllRequestsAsync(void) {
|
|
|
|
|
|
+ return (pBusContext->ConfigFlags & BD_CONFIG_SDREQ_FORCE_ALL_ASYNC);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE SDIO_STATUS CallHcdRequest(PSDHCD pHcd) {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pHcd->pCurrentRequest->Flags & SDREQ_FLAGS_PSEUDO) {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: PSEUDO Request 0x%X \n",
|
|
|
|
|
|
+ (INT)pHcd->pCurrentRequest));
|
|
|
|
|
|
+ /* return successful completion so that processing can finish */
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (ForceAllRequestsAsync()) {
|
|
|
|
|
|
+ /* all requests must be completed(indicated) in a separate context */
|
|
|
|
|
|
+ pHcd->pCurrentRequest->Flags |= SDREQ_FLAGS_FORCE_DEFERRED_COMPLETE;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* otherwise perform a test on flags in the HCD */
|
|
|
|
|
|
+ if (!CHECK_API_VERSION_COMPAT(pHcd,2,6) &&
|
|
|
|
|
|
+ AtomicTest_Set(&pHcd->HcdFlags, HCD_REQUEST_CALL_BIT)) {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* bit was already set, this is a recursive call,
|
|
|
|
|
|
+ * we need to tell the HCD to complete the
|
|
|
|
|
|
+ * request in a separate context */
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Recursive CallHcdRequest \n"));
|
|
|
|
|
|
+ pHcd->pCurrentRequest->Flags |= SDREQ_FLAGS_FORCE_DEFERRED_COMPLETE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ #if DEBUG
|
|
|
|
|
|
+ {
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ BOOL forceDeferred;
|
|
|
|
|
|
+ forceDeferred = pHcd->pCurrentRequest->Flags & SDREQ_FLAGS_FORCE_DEFERRED_COMPLETE;
|
|
|
|
|
|
+ status = pHcd->pRequest(pHcd);
|
|
|
|
|
|
+ if (forceDeferred) {
|
|
|
|
|
|
+ /* status better be pending... */
|
|
|
|
|
|
+ DBG_ASSERT(status == SDIO_STATUS_PENDING);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ #else
|
|
|
|
|
|
+ return pHcd->pRequest(pHcd);
|
|
|
|
|
|
+ #endif
|
|
|
|
|
|
+
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* note the caller of this macro must take the HCD lock to protect the count */
|
|
|
|
|
|
+#define CHECK_HCD_RECURSE(pHcd,pReq) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ (pHcd)->Recursion++; \
|
|
|
|
|
|
+ DBG_ASSERT((pHcd)->Recursion < MAX_HCD_RECURSION_RUNAWAY); \
|
|
|
|
|
|
+ if ((pHcd)->Recursion > pBusContext->MaxHcdRecursion) { \
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Recursive Request Count Exceeded (%d) \n",(pHcd)->Recursion)); \
|
|
|
|
|
|
+ (pReq)->Flags |= SDREQ_FLAGS_FORCE_DEFERRED_COMPLETE; \
|
|
|
|
|
|
+ } \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* InternalFlags bit number settings */
|
|
|
|
|
|
+#define SDBD_INIT 1
|
|
|
|
|
|
+#define SDBD_PENDING 15
|
|
|
|
|
|
+#define SDBD_ALLOC_IRQ_SAFE 2
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDBD_ALLOC_IRQ_SAFE_MASK (1 << SDBD_ALLOC_IRQ_SAFE)
|
|
|
|
|
|
+
|
|
|
|
|
|
+static void INLINE DoRequestCompletion(PSDREQUEST pReq, PSDHCD pHcd) {
|
|
|
|
|
|
+ CLEAR_INTERNAL_REQ_FLAGS(pReq);
|
|
|
|
|
|
+ if (pReq->pCompletion != NULL) {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Calling completion on request:0x%X, CMD:%d \n",
|
|
|
|
|
|
+ (INT)pReq, pReq->Command));
|
|
|
|
|
|
+ /* call completion routine, mark request reusable */
|
|
|
|
|
|
+ AtomicTest_Clear(&pReq->InternalFlags, SDBD_PENDING);
|
|
|
|
|
|
+ pReq->pCompletion(pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* mark request reusable */
|
|
|
|
|
|
+ AtomicTest_Clear(&pReq->InternalFlags, SDBD_PENDING);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+THREAD_RETURN CardDetectHelperFunction(POSKERNEL_HELPER pHelper);
|
|
|
|
|
|
+THREAD_RETURN SDIOIrqHelperFunction(POSKERNEL_HELPER pHelper);
|
|
|
|
|
|
+
|
|
|
|
|
|
+void ConvertSPI_Response(PSDREQUEST pReq, UINT8 *pRespBuffer);
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE SDIO_STATUS PostCardDetectEvent(PBDCONTEXT pSDB, HCD_EVENT Event, PSDHCD pHcd) {
|
|
|
|
|
|
+ HCD_EVENT_MESSAGE message;
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ message.Event = Event;
|
|
|
|
|
|
+ message.pHcd = pHcd;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pHcd != NULL) {
|
|
|
|
|
|
+ /* increment HCD reference count to process this HCD message */
|
|
|
|
|
|
+ status = OS_IncHcdReference(pHcd);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* post card detect message */
|
|
|
|
|
|
+ status = SDLIB_PostMessage(pSDB->pCardDetectMsgQueue, &message, sizeof(message));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: PostCardDetectEvent error status %d\n",status));
|
|
|
|
|
|
+ if (pHcd != NULL) {
|
|
|
|
|
|
+ /* decrement count */
|
|
|
|
|
|
+ OS_DecHcdReference(pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* wake card detect helper */
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_HCD_EVENTS, ("SDIO Bus Driver: PostCardDetectEvent waking\n"));
|
|
|
|
|
|
+ return SD_WAKE_OS_HELPER(&pSDB->CardDetectHelper);
|
|
|
|
|
|
+};
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* initialize device fields */
|
|
|
|
|
|
+static INLINE void InitDeviceData(PSDHCD pHcd, PSDDEVICE pDevice) {
|
|
|
|
|
|
+ ZERO_POBJECT(pDevice);
|
|
|
|
|
|
+ SDLIST_INIT(&pDevice->SDList);
|
|
|
|
|
|
+ SDLIST_INIT(&pDevice->FuncListLink);
|
|
|
|
|
|
+ pDevice->pRequest = IssueBusRequest;
|
|
|
|
|
|
+ pDevice->pConfigure = IssueBusConfig;
|
|
|
|
|
|
+ pDevice->AllocRequest = IssueAllocRequest;
|
|
|
|
|
|
+ pDevice->FreeRequest = IssueFreeRequest;
|
|
|
|
|
|
+ /* set card flags in the ID */
|
|
|
|
|
|
+ pDevice->pId[0].CardFlags = pHcd->CardProperties.Flags;
|
|
|
|
|
|
+ pDevice->pFunction = NULL;
|
|
|
|
|
|
+ pDevice->pHcd = pHcd;
|
|
|
|
|
|
+ SET_SDIO_STACK_VERSION(pDevice);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* de-initialize device fields */
|
|
|
|
|
|
+static INLINE void DeinitDeviceData(PSDDEVICE pDevice) {
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* reset hcd state */
|
|
|
|
|
|
+static INLINE void ResetHcdState(PSDHCD pHcd) {
|
|
|
|
|
|
+ ZERO_POBJECT(&pHcd->CardProperties);
|
|
|
|
|
|
+ pHcd->PendingHelperIrqs = 0;
|
|
|
|
|
|
+ pHcd->PendingIrqAcks = 0;
|
|
|
|
|
|
+ pHcd->IrqsEnabled = 0;
|
|
|
|
|
|
+ pHcd->pCurrentRequest = NULL;
|
|
|
|
|
|
+ pHcd->IrqProcState = SDHCD_IDLE;
|
|
|
|
|
|
+ /* mark this device as special */
|
|
|
|
|
|
+ pHcd->pPseudoDev->pId[0].CardFlags = CARD_PSEUDO;
|
|
|
|
|
|
+ pHcd->SlotCurrentAllocated = 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE SDIO_STATUS _IssueConfig(PSDHCD pHcd,
|
|
|
|
|
|
+ SDCONFIG_COMMAND Command,
|
|
|
|
|
|
+ PVOID pData,
|
|
|
|
|
|
+ INT Length){
|
|
|
|
|
|
+ SDCONFIG configHdr;
|
|
|
|
|
|
+ SET_SDCONFIG_CMD_INFO(&configHdr,Command,pData,Length);
|
|
|
|
|
|
+ return CALL_HCD_CONFIG(pHcd,&configHdr);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* prototypes */
|
|
|
|
|
|
+#define _AcquireHcdLock(pHcd)CriticalSectionAcquireSyncIrq(&(pHcd)->HcdCritSection)
|
|
|
|
|
|
+#define _ReleaseHcdLock(pHcd)CriticalSectionReleaseSyncIrq(&(pHcd)->HcdCritSection)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define AcquireHcdLock(pDev) CriticalSectionAcquireSyncIrq(&(pDev)->pHcd->HcdCritSection)
|
|
|
|
|
|
+#define ReleaseHcdLock(pDev) CriticalSectionReleaseSyncIrq(&(pDev)->pHcd->HcdCritSection)
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS OS_AddDevice(PSDDEVICE pDevice, PSDFUNCTION pFunction);
|
|
|
|
|
|
+void OS_RemoveDevice(PSDDEVICE pDevice);
|
|
|
|
|
|
+SDIO_STATUS OS_InitializeDevice(PSDDEVICE pDevice, PSDFUNCTION pFunction);
|
|
|
|
|
|
+SDIO_STATUS SetOperationalBusMode(PSDDEVICE pDevice,
|
|
|
|
|
|
+ PSDCONFIG_BUS_MODE_DATA pBusMode);
|
|
|
|
|
|
+void FreeDevice(PSDDEVICE pDevice);
|
|
|
|
|
|
+BOOL IsPotentialIdMatch(PSD_PNP_INFO pIdsDev, PSD_PNP_INFO pIdsFuncList);
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define CHECK_FUNCTION_DRIVER_VERSION(pF) \
|
|
|
|
|
|
+ (GET_SDIO_STACK_VERSION_MAJOR((pF)) == CT_SDIO_STACK_VERSION_MAJOR(g_Version))
|
|
|
|
|
|
+#define CHECK_HCD_DRIVER_VERSION(pH) \
|
|
|
|
|
|
+ (GET_SDIO_STACK_VERSION_MAJOR((pH)) == CT_SDIO_STACK_VERSION_MAJOR(g_Version))
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* CLARIFICATION on SDREQ_FLAGS_PSEUDO and SDREQ_FLAGS_BARRIER flags :
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * A request marked as PSEUDO is synchronized with bus requests and is not a true request
|
|
|
|
|
|
+ * that is issued to an HCD.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * A request marked with a BARRIER flag requires that the completion routine be called
|
|
|
|
|
|
+ * before the next bus request starts. This is required for HCD requests that can change
|
|
|
|
|
|
+ * bus or clock modes. Changing the clock or bus mode while a bus request is pending
|
|
|
|
|
|
+ * can cause problems.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * */
|
|
|
|
|
|
+#define SD_PSEUDO_REQ_FLAGS \
|
|
|
|
|
|
+ (SDREQ_FLAGS_PSEUDO | SDREQ_FLAGS_BARRIER | SDREQ_FLAGS_TRANS_ASYNC)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#endif /*___BUSDRIVER_H___*/
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/busdriver/sdio_bus.c b/drivers/sdio/stack/busdriver/sdio_bus.c
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..ffc1e9f
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/busdriver/sdio_bus.c
|
|
|
|
|
|
@@ -0,0 +1,2120 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: sdio_bus.c
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: OS independent bus driver support
|
|
|
|
|
|
+@category abstract: HD_Reference Host Controller Driver Interfaces.
|
|
|
|
|
|
+@category abstract: PD_Reference
|
|
|
|
|
|
+ Peripheral Driver Interfaces.
|
|
|
|
|
|
+
|
|
|
|
|
|
+#notes: this file supports the HCD's and generic functions
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define MODULE_NAME SDBUSDRIVER
|
|
|
|
|
|
+#include <linux/sdio/ctsystem.h>
|
|
|
|
|
|
+#include <linux/sdio/sdio_busdriver.h>
|
|
|
|
|
|
+#include <linux/sdio/_sdio_defs.h>
|
|
|
|
|
|
+#include <linux/sdio/sdio_lib.h>
|
|
|
|
|
|
+#include <linux/sdio/mmc_defs.h>
|
|
|
|
|
|
+#include "_busdriver.h"
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* list of host controller bus drivers */
|
|
|
|
|
|
+PBDCONTEXT pBusContext = NULL;
|
|
|
|
|
|
+static void CleanUpBusResources(void);
|
|
|
|
|
|
+static SDIO_STATUS AllocateBusResources(void);
|
|
|
|
|
|
+static PSIGNAL_ITEM BuildSignal(void);
|
|
|
|
|
|
+static void DestroySignal(PSIGNAL_ITEM pSignal);
|
|
|
|
|
|
+
|
|
|
|
|
|
+const CT_VERSION_CODE g_Version = CT_SDIO_STACK_VERSION_CODE;
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * _SDIO_BusDriverInitialize - call once on driver loading
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS _SDIO_BusDriverInitialize(void)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Version: %d.%d\n",
|
|
|
|
|
|
+ CT_SDIO_STACK_VERSION_MAJOR(g_Version),CT_SDIO_STACK_VERSION_MINOR(g_Version)));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: enter _SDIO_BusDriverInitialize\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ /* allocate our internal data initialize it */
|
|
|
|
|
|
+ pBusContext = KernelAlloc(sizeof(BDCONTEXT));
|
|
|
|
|
|
+ if (pBusContext == NULL) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_BusDriverInitialize can't allocate memory.\n"));
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ memset(pBusContext,0,sizeof(BDCONTEXT));
|
|
|
|
|
|
+ SDLIST_INIT(&pBusContext->RequestList);
|
|
|
|
|
|
+ SDLIST_INIT(&pBusContext->HcdList);
|
|
|
|
|
|
+ SDLIST_INIT(&pBusContext->DeviceList);
|
|
|
|
|
|
+ SDLIST_INIT(&pBusContext->FunctionList);
|
|
|
|
|
|
+ SDLIST_INIT(&pBusContext->SignalList);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* setup defaults */
|
|
|
|
|
|
+ pBusContext->RequestRetries = SDMMC_DEFAULT_CMD_RETRIES;
|
|
|
|
|
|
+ pBusContext->CardReadyPollingRetry = SDMMC_DEFAULT_CARD_READY_RETRIES;
|
|
|
|
|
|
+ pBusContext->PowerSettleDelay = SDMMC_POWER_SETTLE_DELAY;
|
|
|
|
|
|
+ pBusContext->DefaultOperClock = MMC_HS_MAX_BUS_CLOCK;
|
|
|
|
|
|
+ pBusContext->DefaultBusMode = SDCONFIG_BUS_WIDTH_4_BIT;
|
|
|
|
|
|
+ pBusContext->RequestListSize = SDBUS_DEFAULT_REQ_LIST_SIZE;
|
|
|
|
|
|
+ pBusContext->SignalSemListSize = SDBUS_DEFAULT_REQ_SIG_SIZE;
|
|
|
|
|
|
+ pBusContext->CDPollingInterval = SDBUS_DEFAULT_CD_POLLING_INTERVAL;
|
|
|
|
|
|
+ pBusContext->DefaultOperBlockLen = SDMMC_DEFAULT_BYTES_PER_BLOCK;
|
|
|
|
|
|
+ pBusContext->DefaultOperBlockCount = SDMMC_DEFAULT_BLOCKS_PER_TRANS;
|
|
|
|
|
|
+ pBusContext->ConfigFlags = BD_DEFAULT_CONFIG_FLAGS;
|
|
|
|
|
|
+ pBusContext->CMD13PollingMultiplier = SDMMC_CMD13_POLLING_MULTIPLIER;
|
|
|
|
|
|
+ pBusContext->MaxHcdRecursion = MAX_HCD_REQ_RECURSION;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* get overrides for the defaults */
|
|
|
|
|
|
+ status = _SDIO_BusGetDefaultSettings(pBusContext);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pBusContext->MaxRequestAllocations = pBusContext->RequestListSize << 1;
|
|
|
|
|
|
+ pBusContext->MaxSignalAllocations = pBusContext->SignalSemListSize << 1;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CriticalSectionInit(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_BusDriverInitialize can't CriticalSectionInit.\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = SemaphoreInitialize(&pBusContext->HcdListSem, 1);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_BusDriverInitialize can't SemaphoreInitialize HcdListSem.\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = SemaphoreInitialize(&pBusContext->DeviceListSem, 1);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_BusDriverInitialize can't SemaphoreInitialize DeviceListSem.\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = SemaphoreInitialize(&pBusContext->FunctionListSem, 1);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_BusDriverInitialize can't SemaphoreInitialize FunctionListSem.\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = AllocateBusResources();
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_BusDriverInitialize can't AllocateBusResources.\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pBusContext->InitMask |= RESOURCE_INIT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pBusContext->pCardDetectMsgQueue = SDLIB_CreateMessageQueue(MAX_CARD_DETECT_MSGS,
|
|
|
|
|
|
+ sizeof(HCD_EVENT_MESSAGE));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (NULL == pBusContext->pCardDetectMsgQueue) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_BusDriverInitialize can't CreateMessageQueue.\n"));
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = SDLIB_OSCreateHelper(&pBusContext->CardDetectHelper,
|
|
|
|
|
|
+ CardDetectHelperFunction,
|
|
|
|
|
|
+ NULL);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_BusDriverInitialize can't OSCreateHelper.\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pBusContext->InitMask |= HELPER_INIT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = InitializeTimers();
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_BusDriverInitialize can't InitializeTimers.\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ pBusContext->InitMask |= BD_TIMER_INIT;
|
|
|
|
|
|
+ } while(FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ _SDIO_BusDriverCleanup();
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * _SDIO_BusDriverBusDriverCleanup - call once on driver unloading
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+void _SDIO_BusDriverCleanup(void) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: _SDIO_BusDriverCleanup\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pBusContext->InitMask & BD_TIMER_INIT) {
|
|
|
|
|
|
+ CleanupTimers();
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pBusContext->InitMask & HELPER_INIT) {
|
|
|
|
|
|
+ SDLIB_OSDeleteHelper(&pBusContext->CardDetectHelper);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pBusContext->pCardDetectMsgQueue != NULL) {
|
|
|
|
|
|
+ SDLIB_DeleteMessageQueue(pBusContext->pCardDetectMsgQueue);
|
|
|
|
|
|
+ pBusContext->pCardDetectMsgQueue = NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* remove functions */
|
|
|
|
|
|
+ RemoveAllFunctions();
|
|
|
|
|
|
+ /* cleanup all devices */
|
|
|
|
|
|
+ DeleteDevices(NULL);
|
|
|
|
|
|
+ CleanUpBusResources();
|
|
|
|
|
|
+ CriticalSectionDelete(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+ SemaphoreDelete(&pBusContext->HcdListSem);
|
|
|
|
|
|
+ SemaphoreDelete(&pBusContext->DeviceListSem);
|
|
|
|
|
|
+ SemaphoreDelete(&pBusContext->FunctionListSem);
|
|
|
|
|
|
+ KernelFree(pBusContext);
|
|
|
|
|
|
+ pBusContext = NULL;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("-SDIO Bus Driver: _SDIO_BusDriverCleanup\n"));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* cleanup hcd */
|
|
|
|
|
|
+static void CleanupHcd(PSDHCD pHcd)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDLIB_OSDeleteHelper(&pHcd->SDIOIrqHelper);
|
|
|
|
|
|
+ CleanupRequestQueue(&pHcd->CompletedRequestQueue);
|
|
|
|
|
|
+ CleanupRequestQueue(&pHcd->RequestQueue);
|
|
|
|
|
|
+ CriticalSectionDelete(&pHcd->HcdCritSection);
|
|
|
|
|
|
+ SemaphoreDelete(&pHcd->ConfigureOpsSem);
|
|
|
|
|
|
+ pHcd->pCurrentRequest = NULL;
|
|
|
|
|
|
+ if (pHcd->pPseudoDev != NULL) {
|
|
|
|
|
|
+ FreeDevice(pHcd->pPseudoDev);
|
|
|
|
|
|
+ pHcd->pPseudoDev = NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* set up the hcd */
|
|
|
|
|
|
+static SDIO_STATUS SetupHcd(PSDHCD pHcd)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ ZERO_POBJECT(&pHcd->SDIOIrqHelper);
|
|
|
|
|
|
+ ZERO_POBJECT(&pHcd->ConfigureOpsSem);
|
|
|
|
|
|
+ ZERO_POBJECT(&pHcd->HcdCritSection);
|
|
|
|
|
|
+ ZERO_POBJECT(&pHcd->RequestQueue);
|
|
|
|
|
|
+ ZERO_POBJECT(&pHcd->CompletedRequestQueue);
|
|
|
|
|
|
+ pHcd->pPseudoDev = NULL;
|
|
|
|
|
|
+ pHcd->Recursion = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pHcd->pPseudoDev = AllocateDevice(pHcd);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (NULL == pHcd->pPseudoDev) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ ResetHcdState(pHcd);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = SemaphoreInitialize(&pHcd->ConfigureOpsSem,1);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = CriticalSectionInit(&pHcd->HcdCritSection);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = InitializeRequestQueue(&pHcd->RequestQueue);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = InitializeRequestQueue(&pHcd->CompletedRequestQueue);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* create SDIO Irq helper */
|
|
|
|
|
|
+ status = SDLIB_OSCreateHelper(&pHcd->SDIOIrqHelper,
|
|
|
|
|
|
+ SDIOIrqHelperFunction,
|
|
|
|
|
|
+ (PVOID)pHcd);
|
|
|
|
|
|
+ } while(FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* undo what we did */
|
|
|
|
|
|
+ CleanupHcd(pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * _SDIO_RegisterHostController - register a host controller bus driver
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Register a host controller driver with the bus driver.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDIO_RegisterHostController
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDIO_RegisterHostController (PSDHCD pHcd)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pHcd - the host controller definition structure.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS - SDIO_STATUS_SUCCESS when successful.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Each host controller driver must register with the bus driver when loaded.
|
|
|
|
|
|
+ The driver registers an SDHCD structure initialized with hardware properties
|
|
|
|
|
|
+ and callback functions for bus requests and configuration. On multi-slot
|
|
|
|
|
|
+ hardware ,each slot should be registered with a separate SDHCD structure.
|
|
|
|
|
|
+ The bus driver views each slot as a seperate host controller object.
|
|
|
|
|
|
+ The driver should be prepared to receive configuration requests before
|
|
|
|
|
|
+ this call returns. The host controller driver must unregister itself when
|
|
|
|
|
|
+ shutting down.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Registering a host controller driver:
|
|
|
|
|
|
+ static SDHCD Hcd = {
|
|
|
|
|
|
+ .pName = "sdio_custom_hcd",
|
|
|
|
|
|
+ .Version = CT_SDIO_STACK_VERSION_CODE, // set stack version code
|
|
|
|
|
|
+ .SlotNumber = 0, // bus driver internal use
|
|
|
|
|
|
+ .Attributes = SDHCD_ATTRIB_BUS_1BIT | SDHCD_ATTRIB_BUS_4BIT | SDHCD_ATTRIB_MULTI_BLK_IRQ
|
|
|
|
|
|
+ SDHCD_ATTRIB_AUTO_CMD12 ,
|
|
|
|
|
|
+ .MaxBytesPerBlock = 2048 // each data block can be up to 2048 bytes
|
|
|
|
|
|
+ .MaxBlocksPerTrans = 1024, // each data transaction can consist of 1024 blocks
|
|
|
|
|
|
+ .MaxSlotCurrent = 500, // max FET switch current rating
|
|
|
|
|
|
+ .SlotVoltageCaps = SLOT_POWER_3_3V, // only 3.3V operation
|
|
|
|
|
|
+ .SlotVoltagePreferred = SLOT_POWER_3_3V,
|
|
|
|
|
|
+ .MaxClockRate = 24000000, // 24 Mhz max operation
|
|
|
|
|
|
+ .pContext = &HcdContext, // set our driver context
|
|
|
|
|
|
+ .pRequest = HcdRequest, // set SDIO bus request callback
|
|
|
|
|
|
+ .pConfigure = HcdConfig, // set SDIO bus configuration callback
|
|
|
|
|
|
+ };
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SDIO_RegisterHostController(&Hcd)))) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO HCD - failed to register with host, status =%d\n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDIO_UnregisterHostController
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _SDIO_RegisterHostController(PSDHCD pHcd) {
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: _SDIO_RegisterHostController - %s\n",pHcd->pName));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: Host Controller Stack Version: %d.%d \n",
|
|
|
|
|
|
+ GET_SDIO_STACK_VERSION_MAJOR(pHcd),GET_SDIO_STACK_VERSION_MINOR(pHcd)));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!CHECK_HCD_DRIVER_VERSION(pHcd)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: HCD Major Version Mismatch (hcd = %d, bus driver = %d)\n",
|
|
|
|
|
|
+ GET_SDIO_STACK_VERSION_MAJOR(pHcd), CT_SDIO_STACK_VERSION_MAJOR(g_Version)));
|
|
|
|
|
|
+ return SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* setup hcd */
|
|
|
|
|
|
+ status = SetupHcd(pHcd);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ INT slotNumber;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* protect the HCD list */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePendInterruptable(&pBusContext->HcdListSem)))) {
|
|
|
|
|
|
+ break; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* find a unique number for this HCD, must be done under semaphore protection */
|
|
|
|
|
|
+ slotNumber = FirstClearBit(&pBusContext->HcdInUseField);
|
|
|
|
|
|
+ if (slotNumber < 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_RegisterHostController, error, slotNumber exceeded\n"));
|
|
|
|
|
|
+ /* fake something */
|
|
|
|
|
|
+ slotNumber = 31;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ SetBit(&pBusContext->HcdInUseField, slotNumber);
|
|
|
|
|
|
+ pHcd->SlotNumber = slotNumber;
|
|
|
|
|
|
+ /* add HCD to the end of the internal list */
|
|
|
|
|
|
+ SDListAdd(&pBusContext->HcdList , &pHcd->SDList);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePost(&pBusContext->HcdListSem)))) {
|
|
|
|
|
|
+ break; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (pHcd->Attributes & SDHCD_ATTRIB_SLOT_POLLING) {
|
|
|
|
|
|
+ /* post message to card detect helper to do polling */
|
|
|
|
|
|
+ PostCardDetectEvent(pBusContext, EVENT_HCD_CD_POLLING, NULL);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ CleanupHcd(pHcd);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_RegisterHostController, error 0x%X.\n", status));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("-SDIO Bus Driver: _SDIO_RegisterHostController\n"));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Unregister a host controller driver with the bus driver.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDIO_UnregisterHostController
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDIO_UnregisterHostController (PSDHCD pHcd)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pHcd - the host controller definition structure that was registered.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS - SDIO_STATUS_SUCCESS when successful.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Each host controller driver must unregister with the bus driver when
|
|
|
|
|
|
+ unloading. The driver is responsible for halting any outstanding I/O
|
|
|
|
|
|
+ operations. The bus driver will automatically unload function drivers
|
|
|
|
|
|
+ that may be attached assigned to cards inserted into slots.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Unregistering a host controller driver:
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SDIO_UnregisterHostController(&Hcd)))) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO HCD - failed to unregister with host, status =%d\n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDIO_RegisterHostController
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _SDIO_UnregisterHostController(PSDHCD pHcd) {
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: _SDIO_UnregisterHostController\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* remove functions associated with the HCD */
|
|
|
|
|
|
+ RemoveHcdFunctions(pHcd);
|
|
|
|
|
|
+ /* remove any devices associated with the HCD */
|
|
|
|
|
|
+ DeleteDevices(pHcd);
|
|
|
|
|
|
+ /* wait for the message queue to be empty, so we don't have any delayed requests going
|
|
|
|
|
|
+ to this device */
|
|
|
|
|
|
+ while(!SDLIB_IsQueueEmpty(pBusContext->pCardDetectMsgQueue)) {
|
|
|
|
|
|
+ /* wait for the messages to be handled */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: _SDIO_UnregisterHostController, waiting on messages\n"));
|
|
|
|
|
|
+ OSSleep(250);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* protect the HCD list */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePendInterruptable(&pBusContext->HcdListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ ClearBit(&pBusContext->HcdInUseField, pHcd->SlotNumber);
|
|
|
|
|
|
+ /* delete HCD from list */
|
|
|
|
|
|
+ SDListRemove(&pHcd->SDList);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePost(&pBusContext->HcdListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* cleanup anything we allocated */
|
|
|
|
|
|
+ CleanupHcd(pHcd);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("-SDIO Bus Driver: _SDIO_UnregisterHostController\n"));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+cleanup:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_UnregisterHostController, error 0x%X.\n", status));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* documentation headers only for Request and Configure */
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: The bus driver calls the request callback to start an SDIO bus transaction.
|
|
|
|
|
|
+ @function name: Request
|
|
|
|
|
|
+ @prototype: SDIO_STATUS (*pRequest) (struct _SDHCD *pHcd)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pHcd - the host controller structure that was registered
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes:
|
|
|
|
|
|
+ The bus driver maintains an internal queue of SDREQUEST structures submited by function
|
|
|
|
|
|
+ drivers. The driver should use request macros to obtain a pointer to the current SDREQUEST
|
|
|
|
|
|
+ at the head of the queue. The driver can access the fields of the current request in order
|
|
|
|
|
|
+ to program hardware appropriately. Once the request completes, the driver should update
|
|
|
|
|
|
+ the current request information (final status, response bytes and/or data) and call
|
|
|
|
|
|
+ SDIO_HandleHcdEvent() with the event type of EVENT_HCD_TRANSFER_DONE.
|
|
|
|
|
|
+ The bus driver will remove the current request from the head of the queue and start the next
|
|
|
|
|
|
+ request.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of a typical Request callback:
|
|
|
|
|
|
+ SDIO_STATUS HcdRequest(PSDHCD pHcd)
|
|
|
|
|
|
+ {
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ PSDHCD_DRIVER_CONTEXT pHct = (PSDHCD_DRIVER_CONTEXT)pHcd->pContext;
|
|
|
|
|
|
+ UINT32 temp = 0;
|
|
|
|
|
|
+ PSDREQUEST pReq;
|
|
|
|
|
|
+ // get the current request
|
|
|
|
|
|
+ pReq = GET_CURRENT_REQUEST(pHcd);
|
|
|
|
|
|
+ DBG_ASSERT(pReq != NULL);
|
|
|
|
|
|
+ // get controller settings based on response type
|
|
|
|
|
|
+ switch (GET_SDREQ_RESP_TYPE(pReq->Flags)) {
|
|
|
|
|
|
+ case SDREQ_FLAGS_NO_RESP:
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_R1:
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_MMC_R4:
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_MMC_R5:
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_R6:
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_SDIO_R5:
|
|
|
|
|
|
+ temp |= CMDDAT_RES_R1_R4_R5;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_R1B:
|
|
|
|
|
|
+ temp |= (CMDDAT_RES_R1_R4_R5 | CMDAT_RES_BUSY);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_R2:
|
|
|
|
|
|
+ temp |= CMDDAT_RES_R2;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_R3:
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_SDIO_R4:
|
|
|
|
|
|
+ temp |= CMDDAT_RES_R3;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ // check for data
|
|
|
|
|
|
+ if (pReq->Flags & SDREQ_FLAGS_DATA_TRANS){
|
|
|
|
|
|
+ temp |= CMDDAT_DATA_EN;
|
|
|
|
|
|
+ // set data remaining count
|
|
|
|
|
|
+ pReq->DataRemaining = pReq->BlockLen * pReq->BlockCount;
|
|
|
|
|
|
+ DBG_PRINT(TRACE_DATA, ("SDIO %s Data Transfer, Blocks:%d, BlockLen:%d, Total:%d \n",
|
|
|
|
|
|
+ IS_SDREQ_WRITE_DATA(pReq->Flags) ? "TX":"RX",
|
|
|
|
|
|
+ pReq->BlockCount, pReq->BlockLen, pReq->DataRemaining));
|
|
|
|
|
|
+ if (IS_SDREQ_WRITE_DATA(pReq->Flags)) {
|
|
|
|
|
|
+ // write operation
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ // .... program hardware, interrupt handler will complete request
|
|
|
|
|
|
+ return SDIO_STATUS_PENDING;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDIO_HandleHcdEvent
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: The bus driver calls the configure callback to set various options
|
|
|
|
|
|
+ and modes in the host controller hardware.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: Configure
|
|
|
|
|
|
+ @prototype: SDIO_STATUS (*pConfigure) (struct _SDHCD *pHcd, PSDCONFIG pConfig)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pHcd - the host controller structure that was registered
|
|
|
|
|
|
+ @input: pConfig - configuration request structure
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes:
|
|
|
|
|
|
+ The host controller driver recieves configuration requests for options
|
|
|
|
|
|
+ such as slot voltage, bus width, clock rates and interrupt detection.
|
|
|
|
|
|
+ The bus driver guarantees that only one configuration option request
|
|
|
|
|
|
+ can be issued at a time.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of a typical configure callback:
|
|
|
|
|
|
+ SDIO_STATUS HcdConfig(PSDHCD pHcd, PSDCONFIG pConfig)
|
|
|
|
|
|
+ {
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ PSDHCD_DRIVER_CONTEXT pHct = (PSDHCD_DRIVER_CONTEXT)pHcd->pContext;
|
|
|
|
|
|
+ UINT16 command;
|
|
|
|
|
|
+ // get command
|
|
|
|
|
|
+ command = GET_SDCONFIG_CMD(pConfig);
|
|
|
|
|
|
+ // decode command
|
|
|
|
|
|
+ switch (command){
|
|
|
|
|
|
+ case SDCONFIG_GET_WP:
|
|
|
|
|
|
+ if (GetGpioPinLevel(pHct,SDIO_CARD_WP_GPIO) == WP_POLARITY) {
|
|
|
|
|
|
+ *((SDCONFIG_WP_VALUE *)pConfig->pData) = 1;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ *((SDCONFIG_WP_VALUE *)pConfig->pData) = 0;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_SEND_INIT_CLOCKS:
|
|
|
|
|
|
+ ClockStartStop(pHct,CLOCK_ON);
|
|
|
|
|
|
+ // sleep a little, should be at least 80 clocks at our lowest clock setting
|
|
|
|
|
|
+ status = OSSleep(100);
|
|
|
|
|
|
+ ClockStartStop(pHct,CLOCK_OFF);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_SDIO_INT_CTRL:
|
|
|
|
|
|
+ if (GET_SDCONFIG_CMD_DATA(PSDCONFIG_SDIO_INT_CTRL_DATA,pConfig)->SlotIRQEnable) {
|
|
|
|
|
|
+ // request to enable IRQ detection
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ // request to disable IRQ detectioon
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_SDIO_REARM_INT:
|
|
|
|
|
|
+ // request to re-arm the card IRQ detection logic
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_BUS_MODE_CTRL:
|
|
|
|
|
|
+ // request to set bus mode
|
|
|
|
|
|
+ {
|
|
|
|
|
|
+ // get bus mode data structure
|
|
|
|
|
|
+ PSDCONFIG_BUS_MODE_DATA pBusMode =
|
|
|
|
|
|
+ GET_SDCONFIG_CMD_DATA(PSDCONFIG_SDIO_INT_CTRL_DATA,pConfig);
|
|
|
|
|
|
+ // set bus mode based on settings in bus mode structure
|
|
|
|
|
|
+ // bus mode : pBusMode->BusModeFlags
|
|
|
|
|
|
+ // clock rate : pBusMode->ClockRate
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_POWER_CTRL:
|
|
|
|
|
|
+ // request to set power/voltage
|
|
|
|
|
|
+ {
|
|
|
|
|
|
+ PSDCONFIG_POWER_CTRL_DATA pPowerSetting =
|
|
|
|
|
|
+ GET_SDCONFIG_CMD_DATA(PSDCONFIG_POWER_CTRL_DATA,pConfig);
|
|
|
|
|
|
+ if (pPowerSetting->SlotPowerEnable) {
|
|
|
|
|
|
+ // turn on slot power
|
|
|
|
|
|
+ //
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ // turn off slot power
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(PXA_TRACE_CONFIG, ("SDIO PXA255 PwrControl: En:%d, VCC:0x%X \n",
|
|
|
|
|
|
+ pPowerSetting->SlotPowerEnable,
|
|
|
|
|
|
+ pPowerSetting->SlotPowerVoltageMask));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ // unsupported
|
|
|
|
|
|
+ status = SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * Allocate a Device instance
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+PSDDEVICE AllocateDevice(PSDHCD pHcd)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSDDEVICE pDevice;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pDevice = KernelAlloc(sizeof(SDDEVICE));
|
|
|
|
|
|
+ if (pDevice != NULL) {
|
|
|
|
|
|
+ InitDeviceData(pHcd,pDevice);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return pDevice;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * Free a Device instance
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+void FreeDevice(PSDDEVICE pDevice)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ DeinitDeviceData(pDevice);
|
|
|
|
|
|
+ KernelFree(pDevice);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * add this device to the list
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+BOOL AddDeviceToList(PSDDEVICE pDevice)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ BOOL success = FALSE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ /* protect the driver list */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(SemaphorePendInterruptable(&pBusContext->DeviceListSem))) {
|
|
|
|
|
|
+ break; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* add new device to the internal list */
|
|
|
|
|
|
+ SDListAdd(&pBusContext->DeviceList , &pDevice->SDList);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(SemaphorePost(&pBusContext->DeviceListSem))) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ success = TRUE;
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return success;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * Delete device associated with the HCD
|
|
|
|
|
|
+ * if pHCD is NULL this function cleans up all devices, the caller
|
|
|
|
|
|
+ * better have cleaned up functions first!
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+SDIO_STATUS DeleteDevices(PSDHCD pHcd)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ PSDDEVICE pDevice;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: DeleteDevices hcd:0x%X \n", (INT)pHcd));
|
|
|
|
|
|
+ /* protect the device list */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePendInterruptable(&pBusContext->DeviceListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ SDITERATE_OVER_LIST_ALLOW_REMOVE(&pBusContext->DeviceList,pDevice,SDDEVICE,SDList) {
|
|
|
|
|
|
+ /* only remove devices for the hcd or if we are cleaning up all */
|
|
|
|
|
|
+ if ((NULL == pHcd) || (pDevice->pHcd == pHcd)) {
|
|
|
|
|
|
+ SDListRemove(&pDevice->SDList);
|
|
|
|
|
|
+ DeinitDeviceData(pDevice);
|
|
|
|
|
|
+ FreeDevice(pDevice);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }SDITERATE_END;
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePost(&pBusContext->DeviceListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("-SDIO Bus Driver: DeleteDevices \n"));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+cleanup:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("-SDIO Bus Driver: DeleteDevice, error exit 0x%X\n", status));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+static SDIO_STATUS AllocateBusResources(void)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ INT ii;
|
|
|
|
|
|
+ PSDREQUEST pReq;
|
|
|
|
|
|
+ PSIGNAL_ITEM pSignal;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("+SDIO Bus Driver: AllocateBusResources (R:%d,S:%d) (CR:%d,MR:%d)(CS:%d,MS:%d) \n",
|
|
|
|
|
|
+ pBusContext->RequestListSize,
|
|
|
|
|
|
+ pBusContext->SignalSemListSize,
|
|
|
|
|
|
+ pBusContext->CurrentRequestAllocations,pBusContext->MaxRequestAllocations,
|
|
|
|
|
|
+ pBusContext->CurrentSignalAllocations,pBusContext->MaxSignalAllocations));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* allocate some initial requests */
|
|
|
|
|
|
+ for (ii = 0; ii < pBusContext->RequestListSize; ii++) {
|
|
|
|
|
|
+ pReq = AllocateRequest();
|
|
|
|
|
|
+ if (pReq == NULL) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* free requests adds the request to the list */
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ for (ii = 0; ii < pBusContext->SignalSemListSize; ii++) {
|
|
|
|
|
|
+ pSignal = AllocateSignal();
|
|
|
|
|
|
+ if (pSignal == NULL) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* freeing it adds it to the list */
|
|
|
|
|
|
+ FreeSignal(pSignal);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("-SDIO Bus Driver: AllocateBusResources\n"));
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* cleanup bus resources */
|
|
|
|
|
|
+static void CleanUpBusResources(void)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSDLIST pItem;
|
|
|
|
|
|
+ PSDREQUEST pReq;
|
|
|
|
|
|
+ PSIGNAL_ITEM pSignal;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: CleanUpBusResources (CR:%d,MR:%d)(CS:%d,MS:%d) \n",
|
|
|
|
|
|
+ pBusContext->CurrentRequestAllocations,pBusContext->MaxRequestAllocations,
|
|
|
|
|
|
+ pBusContext->CurrentSignalAllocations,pBusContext->MaxSignalAllocations));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ while(1) {
|
|
|
|
|
|
+ pItem = SDListRemoveItemFromHead(&pBusContext->RequestList);
|
|
|
|
|
|
+ if (NULL == pItem) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* free the request */
|
|
|
|
|
|
+ pReq = CONTAINING_STRUCT(pItem, SDREQUEST, SDList);
|
|
|
|
|
|
+ if (pReq->InternalFlags & SDBD_ALLOC_IRQ_SAFE_MASK) {
|
|
|
|
|
|
+ KernelFreeIrqSafe(pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ KernelFree(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ pBusContext->CurrentRequestAllocations--;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pBusContext->CurrentRequestAllocations != 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Request allocations are not ZERO! (CR:%d)\n",
|
|
|
|
|
|
+ pBusContext->CurrentRequestAllocations));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ while(1) {
|
|
|
|
|
|
+ pItem = SDListRemoveItemFromHead(&pBusContext->SignalList);
|
|
|
|
|
|
+ if (NULL == pItem) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ pSignal = CONTAINING_STRUCT(pItem, SIGNAL_ITEM, SDList);
|
|
|
|
|
|
+ DestroySignal(pSignal);
|
|
|
|
|
|
+ pBusContext->CurrentSignalAllocations--;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pBusContext->CurrentSignalAllocations != 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Signal allocations are not ZERO! (CR:%d)\n",
|
|
|
|
|
|
+ pBusContext->CurrentRequestAllocations));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("-SDIO Bus Driver: CleanUpBusResources\n"));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* free a request to the lookaside list */
|
|
|
|
|
|
+void FreeRequest(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CriticalSectionAcquireSyncIrq(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+ /* protect request list */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if ((pBusContext->CurrentRequestAllocations <= pBusContext->MaxRequestAllocations) ||
|
|
|
|
|
|
+ !(pReq->InternalFlags & SDBD_ALLOC_IRQ_SAFE_MASK)) {
|
|
|
|
|
|
+ /* add it to the list */
|
|
|
|
|
|
+ SDListAdd(&pBusContext->RequestList, &pReq->SDList);
|
|
|
|
|
|
+ /* we will hold onto this one */
|
|
|
|
|
|
+ pReq = NULL;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* decrement count */
|
|
|
|
|
|
+ pBusContext->CurrentRequestAllocations--;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CriticalSectionReleaseSyncIrq(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pReq != NULL) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Free Request allocation (CR:%d,MR:%d)\n",
|
|
|
|
|
|
+ pBusContext->CurrentRequestAllocations,pBusContext->MaxRequestAllocations));
|
|
|
|
|
|
+ if (pReq->InternalFlags & SDBD_ALLOC_IRQ_SAFE_MASK) {
|
|
|
|
|
|
+ KernelFreeIrqSafe(pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* we should never free the ones that were normally allocated */
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* allocate a request from the lookaside list */
|
|
|
|
|
|
+PSDREQUEST AllocateRequest(void)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSDLIST pItem;
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ PSDREQUEST pReq = NULL;
|
|
|
|
|
|
+ ATOMIC_FLAGS internalflags;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CriticalSectionAcquireSyncIrq(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pBusContext->InitMask & RESOURCE_INIT) {
|
|
|
|
|
|
+ /* check the list, we are now running... */
|
|
|
|
|
|
+ pItem = SDListRemoveItemFromHead(&pBusContext->RequestList);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* we are loading the list with requests at initialization */
|
|
|
|
|
|
+ pItem = NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = CriticalSectionReleaseSyncIrq(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pItem != NULL) {
|
|
|
|
|
|
+ pReq = CONTAINING_STRUCT(pItem, SDREQUEST, SDList);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ if (pBusContext->InitMask & RESOURCE_INIT) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Request List empty..allocating new one (irq-safe) (CR:%d,MR:%d)\n",
|
|
|
|
|
|
+ pBusContext->CurrentRequestAllocations,pBusContext->MaxRequestAllocations));
|
|
|
|
|
|
+ /* the resource list was already allocated, we must be running now.
|
|
|
|
|
|
+ * at run-time, we allocate using the safe IRQ */
|
|
|
|
|
|
+ pReq = (PSDREQUEST)KernelAllocIrqSafe(sizeof(SDREQUEST));
|
|
|
|
|
|
+ /* mark that this one was created using IRQ safe allocation */
|
|
|
|
|
|
+ internalflags = SDBD_ALLOC_IRQ_SAFE_MASK;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* use the normal allocation since we are called at initialization */
|
|
|
|
|
|
+ pReq = (PSDREQUEST)KernelAlloc(sizeof(SDREQUEST));
|
|
|
|
|
|
+ internalflags = 0;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pReq != NULL) {
|
|
|
|
|
|
+ pReq->InternalFlags = internalflags;
|
|
|
|
|
|
+ /* keep track of allocations */
|
|
|
|
|
|
+ status = CriticalSectionAcquireSyncIrq(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+ pBusContext->CurrentRequestAllocations++;
|
|
|
|
|
|
+ status = CriticalSectionReleaseSyncIrq(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pReq != NULL) {
|
|
|
|
|
|
+ /* preserve internal flags */
|
|
|
|
|
|
+ internalflags = pReq->InternalFlags;
|
|
|
|
|
|
+ ZERO_POBJECT(pReq);
|
|
|
|
|
|
+ pReq->InternalFlags = internalflags;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return pReq;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+void DestroySignal(PSIGNAL_ITEM pSignal)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SignalDelete(&pSignal->Signal);
|
|
|
|
|
|
+ KernelFree(pSignal);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+PSIGNAL_ITEM BuildSignal(void)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSIGNAL_ITEM pSignal;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pSignal = (PSIGNAL_ITEM)KernelAlloc(sizeof(SIGNAL_ITEM));
|
|
|
|
|
|
+ if (pSignal != NULL) {
|
|
|
|
|
|
+ /* initialize signal */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(SignalInitialize(&pSignal->Signal))) {
|
|
|
|
|
|
+ KernelFree(pSignal);
|
|
|
|
|
|
+ pSignal = NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return pSignal;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/* free a signal*/
|
|
|
|
|
|
+void FreeSignal(PSIGNAL_ITEM pSignal)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CriticalSectionAcquireSyncIrq(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pBusContext->CurrentSignalAllocations <= pBusContext->MaxSignalAllocations) {
|
|
|
|
|
|
+ /* add it to the list */
|
|
|
|
|
|
+ SDListAdd(&pBusContext->SignalList, &pSignal->SDList);
|
|
|
|
|
|
+ /* flag that we are holding onto it */
|
|
|
|
|
|
+ pSignal = NULL;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* decrement count */
|
|
|
|
|
|
+ pBusContext->CurrentSignalAllocations--;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CriticalSectionReleaseSyncIrq(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pSignal != NULL) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Free signal allocation (CS:%d,MS:%d)\n",
|
|
|
|
|
|
+ pBusContext->CurrentSignalAllocations,pBusContext->MaxSignalAllocations));
|
|
|
|
|
|
+ DestroySignal(pSignal);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* allocate a signal from the list */
|
|
|
|
|
|
+PSIGNAL_ITEM AllocateSignal(void)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSDLIST pItem;
|
|
|
|
|
|
+ PSIGNAL_ITEM pSignal;
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CriticalSectionAcquireSyncIrq(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pBusContext->InitMask & RESOURCE_INIT) {
|
|
|
|
|
|
+ /* check the list */
|
|
|
|
|
|
+ pItem = SDListRemoveItemFromHead(&pBusContext->SignalList);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* we are loading the list */
|
|
|
|
|
|
+ pItem = NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CriticalSectionReleaseSyncIrq(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+ if (pItem != NULL) {
|
|
|
|
|
|
+ /* return the one from the list */
|
|
|
|
|
|
+ pSignal = CONTAINING_STRUCT(pItem, SIGNAL_ITEM, SDList);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ if (pBusContext->InitMask & RESOURCE_INIT) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Signal List empty..allocating new one (CS:%d,MS:%d)\n",
|
|
|
|
|
|
+ pBusContext->CurrentSignalAllocations,pBusContext->MaxSignalAllocations));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* just allocate one */
|
|
|
|
|
|
+ pSignal = BuildSignal();
|
|
|
|
|
|
+ status = CriticalSectionAcquireSyncIrq(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+ if (pSignal != NULL) {
|
|
|
|
|
|
+ pBusContext->CurrentSignalAllocations++;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = CriticalSectionReleaseSyncIrq(&pBusContext->RequestListCritSection);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return pSignal;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * Issus Bus Request (exposed to function drivers)
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+PSDREQUEST IssueAllocRequest(PSDDEVICE pDev)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ return AllocateRequest();
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * Free Request (exposed to function drivers)
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+void IssueFreeRequest(PSDDEVICE pDev, PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * Issus Bus Request (exposed to function drivers)
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS IssueBusRequest(PSDDEVICE pDev, PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ pReq->pFunction = pDev->pFunction;
|
|
|
|
|
|
+ return IssueRequestToHCD(pDev->pHcd,pReq);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* completion routine for HCD configs, this is synchronized with normal bus requests */
|
|
|
|
|
|
+static void HcdConfigComplete(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pReq->Status = CALL_HCD_CONFIG((PSDHCD)pReq->pDataBuffer, (PSDCONFIG)pReq->pCompleteContext);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ SignalSet(&((PSIGNAL_ITEM)pReq->pHcdContext)->Signal);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SendSyncedHcdBusConfig(PSDDEVICE pDevice, PSDCONFIG pConfig)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ PSDREQUEST pReq = NULL;
|
|
|
|
|
|
+ PSIGNAL_ITEM pSignal = NULL;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pSignal = AllocateSignal();
|
|
|
|
|
|
+ if (NULL == pSignal) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pReq = AllocateRequest();
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* issue pseudo request to sync this with bus requests */
|
|
|
|
|
|
+ pReq->pCompletion = HcdConfigComplete;
|
|
|
|
|
|
+ pReq->pCompleteContext = pConfig;
|
|
|
|
|
|
+ /* re-use hcd context to store the signal since this request
|
|
|
|
|
|
+ * never actually goes to an HCD */
|
|
|
|
|
|
+ pReq->pHcdContext = pSignal;
|
|
|
|
|
|
+ pReq->pDataBuffer = pDevice->pHcd;
|
|
|
|
|
|
+ /* flag this as barrier in case it may change the bus mode of the HCD */
|
|
|
|
|
|
+ pReq->Flags = SDREQ_FLAGS_PSEUDO | SDREQ_FLAGS_BARRIER | SDREQ_FLAGS_TRANS_ASYNC;
|
|
|
|
|
|
+ pReq->Status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* issue request */
|
|
|
|
|
|
+ status = IssueRequestToHCD(pDevice->pHcd,pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Config Request Sync-Op waiting....\n"));
|
|
|
|
|
|
+ status = SignalWait(&pSignal->Signal);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* return the result of the configuration request */
|
|
|
|
|
|
+ status = pReq->Status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* cleanup */
|
|
|
|
|
|
+ if (pReq != NULL) {
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pSignal != NULL) {
|
|
|
|
|
|
+ FreeSignal(pSignal);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * Issus bus Configuration (exposed to function drivers)
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS IssueBusConfig(PSDDEVICE pDev, PSDCONFIG pConfig)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ INT cmdLength;
|
|
|
|
|
|
+ UINT8 debugLevel = SDDBG_ERROR;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ cmdLength = GET_SDCONFIG_CMD_LEN(pConfig);
|
|
|
|
|
|
+ status = SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ /* check buffers and length */
|
|
|
|
|
|
+ if (IS_SDCONFIG_CMD_GET(pConfig) || IS_SDCONFIG_CMD_PUT(pConfig)) {
|
|
|
|
|
|
+ if ((GET_SDCONFIG_CMD_DATA(PVOID,pConfig) == NULL) || (0 == cmdLength)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ switch (GET_SDCONFIG_CMD(pConfig)) {
|
|
|
|
|
|
+ case SDCONFIG_FUNC_ACK_IRQ:
|
|
|
|
|
|
+ status = SDFunctionAckInterrupt(pDev);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_FUNC_ENABLE_DISABLE:
|
|
|
|
|
|
+ if (cmdLength < sizeof(SDCONFIG_FUNC_ENABLE_DISABLE_DATA)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = SDEnableFunction(pDev,
|
|
|
|
|
|
+ GET_SDCONFIG_CMD_DATA(PSDCONFIG_FUNC_ENABLE_DISABLE_DATA,pConfig));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_FUNC_UNMASK_IRQ:
|
|
|
|
|
|
+ status = SDMaskUnmaskFunctionIRQ(pDev,FALSE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_FUNC_MASK_IRQ:
|
|
|
|
|
|
+ status = SDMaskUnmaskFunctionIRQ(pDev,TRUE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_FUNC_SPI_MODE_DISABLE_CRC:
|
|
|
|
|
|
+ status = SDSPIModeEnableDisableCRC(pDev,FALSE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_FUNC_SPI_MODE_ENABLE_CRC:
|
|
|
|
|
|
+ status = SDSPIModeEnableDisableCRC(pDev,TRUE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_FUNC_ALLOC_SLOT_CURRENT:
|
|
|
|
|
|
+ status = SDAllocFreeSlotCurrent(pDev,
|
|
|
|
|
|
+ TRUE,
|
|
|
|
|
|
+ GET_SDCONFIG_CMD_DATA(PSDCONFIG_FUNC_SLOT_CURRENT_DATA,pConfig));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_FUNC_FREE_SLOT_CURRENT:
|
|
|
|
|
|
+ status = SDAllocFreeSlotCurrent(pDev, FALSE, NULL);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_FUNC_CHANGE_BUS_MODE:
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = SetOperationalBusMode(pDev,
|
|
|
|
|
|
+ GET_SDCONFIG_CMD_DATA(PSDCONFIG_BUS_MODE_DATA,
|
|
|
|
|
|
+ pConfig));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_FUNC_NO_IRQ_PEND_CHECK:
|
|
|
|
|
|
+ status = TryNoIrqPendingCheck(pDev);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (GET_SDCONFIG_CMD(pConfig) & SDCONFIG_FLAGS_HC_CONFIG) {
|
|
|
|
|
|
+ /* synchronize config requests with busrequests */
|
|
|
|
|
|
+ status = SendSyncedHcdBusConfig(pDev,pConfig);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: IssueBusConfig - unknown command:0x%X \n",
|
|
|
|
|
|
+ GET_SDCONFIG_CMD(pConfig)));
|
|
|
|
|
|
+ status = SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } while(FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if(status == SDIO_STATUS_FUNC_ENABLE_TIMEOUT ){ /* reduce debug level to avoid timeout error messages */
|
|
|
|
|
|
+ debugLevel = SDDBG_TRACE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(debugLevel,
|
|
|
|
|
|
+ ("SDIO Bus Driver: IssueBusConfig - Error in command:0x%X, Buffer:0x%X, Length:%d Err:%d\n",
|
|
|
|
|
|
+ GET_SDCONFIG_CMD(pConfig),
|
|
|
|
|
|
+ GET_SDCONFIG_CMD_DATA(INT,pConfig),
|
|
|
|
|
|
+ cmdLength, status));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* start a request */
|
|
|
|
|
|
+static INLINE SDIO_STATUS StartHcdRequest(PSDHCD pHcd, PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if ((pReq->pFunction != NULL) && (pReq->pFunction->Flags & SDFUNCTION_FLAG_REMOVING)) {
|
|
|
|
|
|
+ /* this device or function is going away, fail any new requests */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: StartHcdRequest, fail request 0x%X, device is removing\n", (UINT)pReq));
|
|
|
|
|
|
+ pReq->Status = SDIO_STATUS_CANCELED;
|
|
|
|
|
|
+ return SDIO_STATUS_SDREQ_QUEUE_FAILED;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _AcquireHcdLock(pHcd);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to acquire HCD request lock: Err:%d\n", status));
|
|
|
|
|
|
+ pReq->Status = SDIO_STATUS_SDREQ_QUEUE_FAILED;
|
|
|
|
|
|
+ return SDIO_STATUS_SDREQ_QUEUE_FAILED;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pReq->Flags & SDREQ_FLAGS_QUEUE_HEAD) {
|
|
|
|
|
|
+ /* caller wants this request queued to the head */
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* a completion routine for a barrier request is called
|
|
|
|
|
|
+ * while the queue is busy. A barrier request can
|
|
|
|
|
|
+ * insert a new request at the head of the queue */
|
|
|
|
|
|
+ DBG_ASSERT(IsQueueBusy(&pHcd->RequestQueue));
|
|
|
|
|
|
+ QueueRequestToFront(&pHcd->RequestQueue,pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* insert in queue at tail */
|
|
|
|
|
|
+ QueueRequest(&pHcd->RequestQueue,pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* is queue busy ? */
|
|
|
|
|
|
+ if (IsQueueBusy(&pHcd->RequestQueue)) {
|
|
|
|
|
|
+ /* release lock */
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+ /* controller is busy already, no need to call the hcd */
|
|
|
|
|
|
+ return SDIO_STATUS_PENDING;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* mark it as busy */
|
|
|
|
|
|
+ MarkQueueBusy(&pHcd->RequestQueue);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* remove item from head and set current request */
|
|
|
|
|
|
+ SET_CURRENT_REQUEST(pHcd, DequeueRequest(&pHcd->RequestQueue));
|
|
|
|
|
|
+ if (CHECK_API_VERSION_COMPAT(pHcd,2,6)) {
|
|
|
|
|
|
+ CHECK_HCD_RECURSE(pHcd, pHcd->pCurrentRequest);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* release lock */
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+ /* controller was not busy, call into HCD to process current request */
|
|
|
|
|
|
+ status = CallHcdRequest(pHcd);
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* used by CMD12,CMD13 to save the original completion routine */
|
|
|
|
|
|
+#define GET_BD_RSV_REQUEST_COMPLETION(pR) (PSDEQUEST_COMPLETION)(pR)->pBdRsv1
|
|
|
|
|
|
+#define SET_BD_RSV_REQUEST_COMPLETION(pR,c) (pR)->pBdRsv1 = (PVOID)(c)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* used by CMD12 processing to save/restore the original data transfer status */
|
|
|
|
|
|
+#define GET_BD_RSV_ORIG_STATUS(pR) (SDIO_STATUS)(pR)->pBdRsv2
|
|
|
|
|
|
+#define SET_BD_RSV_ORIG_STATUS(pR,s) (pR)->pBdRsv2 = (PVOID)(s)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* used by CMD13 processing to get/set polling count */
|
|
|
|
|
|
+#define GET_BD_RSV_STATUS_POLL_COUNT(pR) (INT)(pR)->pBdRsv2
|
|
|
|
|
|
+#define SET_BD_RSV_STATUS_POLL_COUNT(pR,s) (pR)->pBdRsv2 = (PVOID)(s)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* used by CMD55 processing to save the second part of the request */
|
|
|
|
|
|
+#define GET_BD_RSV_ORIG_REQ(pR) (PSDREQUEST)(pR)->pBdRsv1
|
|
|
|
|
|
+#define SET_BD_RSV_ORIG_REQ(pR,r) (pR)->pBdRsv1 = (PVOID)(r)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* used by all to save HCD */
|
|
|
|
|
|
+#define GET_BD_RSV_HCD(pR) (PSDHCD)(pR)->pBdRsv3
|
|
|
|
|
|
+#define SET_BD_RSV_HCD(pR,h) (pR)->pBdRsv3 = (PVOID)(h)
|
|
|
|
|
|
+
|
|
|
|
|
|
+static void CMD13CompletionBarrier(PSDREQUEST pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE void SetupCMD13(PSDHCD pHcd, PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ pReq->Command = CMD13;
|
|
|
|
|
|
+ /* sequence must be atomic, queue it to the head and flag as a barrier */
|
|
|
|
|
|
+ pReq->Flags = SDREQ_FLAGS_QUEUE_HEAD | SDREQ_FLAGS_BARRIER | SDREQ_FLAGS_TRANS_ASYNC;
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ pReq->Argument = 0;
|
|
|
|
|
|
+ pReq->Flags |= SDREQ_FLAGS_RESP_R2;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ pReq->Flags |= SDREQ_FLAGS_RESP_R1;
|
|
|
|
|
|
+ pReq->Argument |= pHcd->CardProperties.RCA << 16;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* insert completion */
|
|
|
|
|
|
+ pReq->pCompletion = CMD13CompletionBarrier;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* CMD13 (GET STATUS) completion */
|
|
|
|
|
|
+static void CMD13CompletionBarrier(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSDEQUEST_COMPLETION pOrigCompletion = GET_BD_RSV_REQUEST_COMPLETION(pReq);
|
|
|
|
|
|
+ PSDHCD pHcd = GET_BD_RSV_HCD(pReq);
|
|
|
|
|
|
+ INT pollingCount = GET_BD_RSV_STATUS_POLL_COUNT(pReq);
|
|
|
|
|
|
+ BOOL doCompletion = TRUE;
|
|
|
|
|
|
+ UINT32 cardStatus;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_ASSERT(pOrigCompletion != NULL);
|
|
|
|
|
|
+ DBG_ASSERT(pHcd != NULL);
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("+SDIO Bus Driver: CMD13CompletionBarrier (cnt:%d) \n",pollingCount));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(pReq->Status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ cardStatus = SD_R1_GET_CARD_STATUS(pReq->Response);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (cardStatus & SD_CS_TRANSFER_ERRORS) {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS,("SDIO Bus Driver: Card transfer errors : 0x%X \n",cardStatus));
|
|
|
|
|
|
+ pReq->Status = SDIO_STATUS_PROGRAM_STATUS_ERROR;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SD_CS_GET_STATE(cardStatus) != SD_CS_STATE_PRG) {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS,("SDIO Bus Driver: Card programming done \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Card still programming.. \n"));
|
|
|
|
|
|
+ pollingCount--;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pollingCount < 0) {
|
|
|
|
|
|
+ pReq->Status = SDIO_STATUS_PROGRAM_TIMEOUT;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: card programming timeout!\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ doCompletion = FALSE;
|
|
|
|
|
|
+ /* keep trying */
|
|
|
|
|
|
+ SET_BD_RSV_STATUS_POLL_COUNT(pReq, pollingCount);
|
|
|
|
|
|
+ SetupCMD13(pHcd,pReq);
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: re-issuing CMD13 \n"));
|
|
|
|
|
|
+ /* re-issue */
|
|
|
|
|
|
+ IssueRequestToHCD(pHcd, pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (doCompletion) {
|
|
|
|
|
|
+ /* restore original completion routine */
|
|
|
|
|
|
+ pReq->pCompletion = pOrigCompletion;
|
|
|
|
|
|
+ /* call original completion routine */
|
|
|
|
|
|
+ pOrigCompletion(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("-SDIO Bus Driver: CMD13CompletionBarrier \n"));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* command 13 (GET STATUS) preparation */
|
|
|
|
|
|
+static void PrepCMD13Barrier(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = pReq->Status;
|
|
|
|
|
|
+ PSDHCD pHcd = GET_BD_RSV_HCD(pReq);
|
|
|
|
|
|
+ INT pollingCount;
|
|
|
|
|
|
+ PSDEQUEST_COMPLETION pOrigCompletion = GET_BD_RSV_REQUEST_COMPLETION(pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_ASSERT(pHcd != NULL);
|
|
|
|
|
|
+ DBG_ASSERT(pOrigCompletion != NULL);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("+SDIO Bus Driver: PrepCMD13Barrier \n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* re-use the request for CMD13 */
|
|
|
|
|
|
+ SetupCMD13(pHcd,pReq);
|
|
|
|
|
|
+ /* set polling count to a multiple of the Block count, if the BlockCount was
|
|
|
|
|
|
+ * zeroed by the HCD, then set it to 1X multiplier */
|
|
|
|
|
|
+ pollingCount = max(pBusContext->CMD13PollingMultiplier,
|
|
|
|
|
|
+ pBusContext->CMD13PollingMultiplier * (INT)pReq->BlockCount);
|
|
|
|
|
|
+ /* initialize count */
|
|
|
|
|
|
+ SET_BD_RSV_STATUS_POLL_COUNT(pReq, pollingCount);
|
|
|
|
|
|
+ /* re-issue it, we can call IssueRequest here since we are re-using the request */
|
|
|
|
|
|
+ IssueRequestToHCD(pHcd, pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Request Failure (%d) , CMD13 bypassed.\n",status));
|
|
|
|
|
|
+ /* call the original completion routine */
|
|
|
|
|
|
+ pOrigCompletion(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("-SDIO Bus Driver: PrepCMD13Barrier (%d) \n",status));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* CMD12 completion */
|
|
|
|
|
|
+static void CMD12Completion(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSDEQUEST_COMPLETION pOrigCompletion = GET_BD_RSV_REQUEST_COMPLETION(pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_ASSERT(pOrigCompletion != NULL);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("+SDIO Bus Driver: CMD12Completion \n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* restore original completion routine */
|
|
|
|
|
|
+ pReq->pCompletion = pOrigCompletion;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_SUCCESS(pReq->Status)) {
|
|
|
|
|
|
+ /* if CMD12 succeeds, we want to return the result of the original
|
|
|
|
|
|
+ * request */
|
|
|
|
|
|
+ pReq->Status = GET_BD_RSV_ORIG_STATUS(pReq);
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS,
|
|
|
|
|
|
+ ("SDIO Bus Driver: PrepCMD12Completion original status %d \n",pReq->Status));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* call original completion routine */
|
|
|
|
|
|
+ pOrigCompletion(pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("-SDIO Bus Driver: CMD12Completion \n"));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* CMD12 preparation */
|
|
|
|
|
|
+static void PrepCMD12Barrier(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+
|
|
|
|
|
|
+ SDIO_STATUS status = pReq->Status;
|
|
|
|
|
|
+ PSDHCD pHcd = GET_BD_RSV_HCD(pReq);
|
|
|
|
|
|
+ PSDEQUEST_COMPLETION pOrigCompletion = GET_BD_RSV_REQUEST_COMPLETION(pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_ASSERT(pHcd != NULL);
|
|
|
|
|
|
+ DBG_ASSERT(pOrigCompletion != NULL);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("+SDIO Bus Driver: PrepCMD12Barrier \n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status) || /* only issue CMD12 on success or specific bus errors */
|
|
|
|
|
|
+ (SDIO_STATUS_BUS_READ_TIMEOUT == status) ||
|
|
|
|
|
|
+ (SDIO_STATUS_BUS_READ_CRC_ERR == status) ||
|
|
|
|
|
|
+ (SDIO_STATUS_BUS_WRITE_ERROR == status)) {
|
|
|
|
|
|
+ if (!CHECK_API_VERSION_COMPAT(pHcd,2,6)) {
|
|
|
|
|
|
+ if (!ForceAllRequestsAsync()) {
|
|
|
|
|
|
+ /* clear the call bit as an optimization, note clearing it wholesale here will
|
|
|
|
|
|
+ * allow request processing to recurse one more level */
|
|
|
|
|
|
+ AtomicTest_Clear(&pHcd->HcdFlags, HCD_REQUEST_CALL_BIT);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* re-use the request for CMD12 */
|
|
|
|
|
|
+ pReq->Command = CMD12;
|
|
|
|
|
|
+ pReq->Argument = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* if the data transfer was successful, check for transfer check */
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status) &&
|
|
|
|
|
|
+ (pReq->Flags & SDREQ_FLAGS_AUTO_TRANSFER_STATUS)) {
|
|
|
|
|
|
+ /* original data request requires a transfer status check, which is another
|
|
|
|
|
|
+ * barrier request */
|
|
|
|
|
|
+ pReq->Flags = SDREQ_FLAGS_RESP_R1B | SDREQ_FLAGS_QUEUE_HEAD | SDREQ_FLAGS_BARRIER |
|
|
|
|
|
|
+ SDREQ_FLAGS_TRANS_ASYNC;
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("-SDIO Bus Driver: PrepCMD12Barrier , chaining CMD13 \n"));
|
|
|
|
|
|
+ /* switch out completion to send the CMD13 next */
|
|
|
|
|
|
+ pReq->pCompletion = PrepCMD13Barrier;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ pReq->Flags = SDREQ_FLAGS_RESP_R1B | SDREQ_FLAGS_QUEUE_HEAD | SDREQ_FLAGS_TRANS_ASYNC;
|
|
|
|
|
|
+ pReq->pCompletion = CMD12Completion;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* save the original data transfer request status */
|
|
|
|
|
|
+ SET_BD_RSV_ORIG_STATUS(pReq,status);
|
|
|
|
|
|
+ /* re-issue it, we can call IssueRequest here since we are re-using the request */
|
|
|
|
|
|
+ IssueRequestToHCD(pHcd, pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Request Failure (%d) , CMD12 bypassed.\n",status));
|
|
|
|
|
|
+ /* call the original completion routine */
|
|
|
|
|
|
+ pOrigCompletion(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("-SDIO Bus Driver: PrepCMD12Barrier (%d) \n",status));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* CMD55 barrier - this is a special barrier completion routine, we have to submit the second
|
|
|
|
|
|
+ * part of the command command sequence atomically */
|
|
|
|
|
|
+static void CMD55CompletionBarrier(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = pReq->Status;
|
|
|
|
|
|
+ PSDREQUEST pOrigReq = GET_BD_RSV_ORIG_REQ(pReq);
|
|
|
|
|
|
+ PSDHCD pHcd = GET_BD_RSV_HCD(pReq);
|
|
|
|
|
|
+ BOOL doCompletion = FALSE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_ASSERT(pOrigReq != NULL);
|
|
|
|
|
|
+ DBG_ASSERT(pHcd != NULL);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("+SDIO Bus Driver: CMD55Completion \n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* command 55 failed */
|
|
|
|
|
|
+ pOrigReq->Status = status;
|
|
|
|
|
|
+ doCompletion = TRUE;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!(SD_R1_GET_CARD_STATUS(pReq->Response) & SD_CS_APP_CMD)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Card is not accepting CMD55, status:0x%X \n",
|
|
|
|
|
|
+ SD_R1_GET_CARD_STATUS(pReq->Response)));
|
|
|
|
|
|
+ pOrigReq->Status = SDIO_STATUS_INVALID_COMMAND;
|
|
|
|
|
|
+ doCompletion = TRUE;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!CHECK_API_VERSION_COMPAT(pHcd,2,6)) {
|
|
|
|
|
|
+ if (!ForceAllRequestsAsync()) {
|
|
|
|
|
|
+ AtomicTest_Clear(&pHcd->HcdFlags, HCD_REQUEST_CALL_BIT);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* flag the original request to queue to the head */
|
|
|
|
|
|
+ pOrigReq->Flags |= SDREQ_FLAGS_QUEUE_HEAD;
|
|
|
|
|
|
+ /* submit original request, we cannot call IssueRequestHCD() here because the
|
|
|
|
|
|
+ * original request has already gone through IssueRequestHCD() already */
|
|
|
|
|
|
+ status = StartHcdRequest(pHcd, pOrigReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_STATUS_PENDING == status) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pOrigReq->Status = status;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_STATUS_SDREQ_QUEUE_FAILED == status) {
|
|
|
|
|
|
+ /* never made it to the queue */
|
|
|
|
|
|
+ doCompletion = TRUE;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* request completed in-line */
|
|
|
|
|
|
+ _SDIO_HandleHcdEvent(pHcd, EVENT_HCD_TRANSFER_DONE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (doCompletion) {
|
|
|
|
|
|
+ DoRequestCompletion(pOrigReq, pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* free the CMD55 request */
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("-SDIO Bus Driver: CMD55Completion \n"));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* synch completion routine */
|
|
|
|
|
|
+static void SynchCompletion(PSDREQUEST pRequest)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSIGNAL_ITEM pSignal;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pSignal = (PSIGNAL_ITEM)pRequest->pCompleteContext;
|
|
|
|
|
|
+ DBG_ASSERT(pSignal != NULL);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(SignalSet(&pSignal->Signal))) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: SynchCompletion - signal failed \n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * Issue a request to the host controller
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following flags are handled internally by the bus driver to guarantee atomicity.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * SDREQ_FLAGS_APP_CMD - SD Extended commands requiring CMD55 to precede the actual command
|
|
|
|
|
|
+ * SDREQ_FLAGS_AUTO_CMD12 - Memory Card Data transfer needs CMD12 to stop transfer
|
|
|
|
|
|
+ * (multi-block reads/writes)
|
|
|
|
|
|
+ * SDREQ_FLAGS_AUTO_TRANSFER_STATUS - Memory card data transfer needs transfer status polling
|
|
|
|
|
|
+ * using CMD13
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * These request flags require additional commands prepended or appended to the original command
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The order of command execution :
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Order Condition Command Issued
|
|
|
|
|
|
+ * -------------------------------------------------------------
|
|
|
|
|
|
+ * 1. If APP_CMD CMD55 issued.
|
|
|
|
|
|
+ * 2. Always Caller command issued.
|
|
|
|
|
|
+ * 3. If AUTO_CMD12 CMD12 issued.
|
|
|
|
|
|
+ * 4. If AUTO_TRANSFER_STATUS CMD13 issued until card programming is complete
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS IssueRequestToHCD(PSDHCD pHcd, PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ PSIGNAL_ITEM pSignal = NULL;
|
|
|
|
|
|
+ BOOL handleFailedReqSubmit = FALSE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ CLEAR_INTERNAL_REQ_FLAGS(pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ /* mark request in-use */
|
|
|
|
|
|
+ ATOMIC_FLAGS internal = AtomicTest_Set(&pReq->InternalFlags, SDBD_PENDING);
|
|
|
|
|
|
+ if (internal & (1<<SDBD_PENDING)) {
|
|
|
|
|
|
+ DBG_ASSERT_WITH_MSG(FALSE,
|
|
|
|
|
|
+ "SDIO Bus Driver: IssueRequestToHCD - request already in use \n");
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Request already in use: 0x%X",(INT)pReq));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!(pReq->Flags & SDREQ_FLAGS_TRANS_ASYNC)) {
|
|
|
|
|
|
+ /* caller wants synchronous operation, insert our completion routine */
|
|
|
|
|
|
+ pReq->pCompletion = SynchCompletion;
|
|
|
|
|
|
+ pSignal = AllocateSignal();
|
|
|
|
|
|
+ if (NULL == pSignal) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ pReq->Status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ handleFailedReqSubmit = TRUE;
|
|
|
|
|
|
+ /* no need to continue */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ pReq->pCompleteContext = (PVOID)pSignal;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if ((pReq->Flags & SDREQ_FLAGS_AUTO_CMD12) &&
|
|
|
|
|
|
+ !(pHcd->Attributes & SDHCD_ATTRIB_AUTO_CMD12) &&
|
|
|
|
|
|
+ !(IS_HCD_BUS_MODE_SPI(pHcd) && IS_SDREQ_WRITE_DATA(pReq->Flags))) {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Auto CMD12 on Request:0x%08X \n",(INT)pReq));
|
|
|
|
|
|
+ /* caller wants CMD12 auto-issued and the HCD does not support it */
|
|
|
|
|
|
+ /* setup caller's request as a barrier and replace their completion routine */
|
|
|
|
|
|
+ pReq->Flags |= SDREQ_FLAGS_BARRIER;
|
|
|
|
|
|
+ /* take off the flag, since the BD will be issuing it */
|
|
|
|
|
|
+ pReq->Flags &= ~SDREQ_FLAGS_AUTO_CMD12;
|
|
|
|
|
|
+ /* save original completion */
|
|
|
|
|
|
+ SET_BD_RSV_REQUEST_COMPLETION(pReq,pReq->pCompletion);
|
|
|
|
|
|
+ /* save the HCD we are on */
|
|
|
|
|
|
+ SET_BD_RSV_HCD(pReq,pHcd);
|
|
|
|
|
|
+ /* use completion for preping CMD12 */
|
|
|
|
|
|
+ pReq->pCompletion = PrepCMD12Barrier;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pReq->Flags & SDREQ_FLAGS_AUTO_TRANSFER_STATUS) {
|
|
|
|
|
|
+ /* caller wants transfer status checked. If a CMD12
|
|
|
|
|
|
+ * barrier request has been setup we let the CMD12 completion take care
|
|
|
|
|
|
+ * of setting up the transfer check */
|
|
|
|
|
|
+ if (pReq->pCompletion != PrepCMD12Barrier) {
|
|
|
|
|
|
+ /* make CMD13 prep a barrier */
|
|
|
|
|
|
+ pReq->Flags |= SDREQ_FLAGS_BARRIER;
|
|
|
|
|
|
+ /* save original completion */
|
|
|
|
|
|
+ SET_BD_RSV_REQUEST_COMPLETION(pReq,pReq->pCompletion);
|
|
|
|
|
|
+ /* save the HCD we are on */
|
|
|
|
|
|
+ SET_BD_RSV_HCD(pReq,pHcd);
|
|
|
|
|
|
+ /* use completion for preping CMD13 */
|
|
|
|
|
|
+ pReq->pCompletion = PrepCMD13Barrier;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check app command, the two command sequence must be handled atomically */
|
|
|
|
|
|
+ if (pReq->Flags & SDREQ_FLAGS_APP_CMD) {
|
|
|
|
|
|
+ PSDREQUEST pCmd55;
|
|
|
|
|
|
+ /* allocate request to handle initial CMD55 command */
|
|
|
|
|
|
+ pCmd55 = AllocateRequest();
|
|
|
|
|
|
+ if (NULL == pCmd55) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ pReq->Status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ /* complete the caller's request with error */
|
|
|
|
|
|
+ handleFailedReqSubmit = TRUE;
|
|
|
|
|
|
+ /* no need to continue */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* first submit CMD55 */
|
|
|
|
|
|
+ /* set RCA */
|
|
|
|
|
|
+ pCmd55->Argument = pHcd->CardProperties.RCA << 16;
|
|
|
|
|
|
+ /* mark as a barrier request */
|
|
|
|
|
|
+ pCmd55->Flags = SDREQ_FLAGS_RESP_R1 | SDREQ_FLAGS_BARRIER | SDREQ_FLAGS_TRANS_ASYNC;
|
|
|
|
|
|
+ pCmd55->Command = CMD55;
|
|
|
|
|
|
+ /* call our barrier completion routine when done */
|
|
|
|
|
|
+ pCmd55->pCompletion = CMD55CompletionBarrier;
|
|
|
|
|
|
+ /* save request and target HCD */
|
|
|
|
|
|
+ SET_BD_RSV_ORIG_REQ(pCmd55,pReq);
|
|
|
|
|
|
+ SET_BD_RSV_HCD(pCmd55,pHcd);
|
|
|
|
|
|
+ /* recursively start the CMD55 request, since the CMD55 is a barrier
|
|
|
|
|
|
+ * request, it's completion routine will submit the actual request
|
|
|
|
|
|
+ * atomically */
|
|
|
|
|
|
+ status = IssueRequestToHCD(pHcd, pCmd55);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* start the normal request */
|
|
|
|
|
|
+ status = StartHcdRequest(pHcd,pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_STATUS_SDREQ_QUEUE_FAILED == status) {
|
|
|
|
|
|
+ handleFailedReqSubmit = TRUE;
|
|
|
|
|
|
+ /* no need to continue, clean up at the end */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* at this point, the request was either queued or was processed by the
|
|
|
|
|
|
+ * HCD */
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: HCD returned status:%d on request: 0x%X, (CMD:%d) \n",
|
|
|
|
|
|
+ status, (INT)pReq, pReq->Command));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (status != SDIO_STATUS_PENDING) {
|
|
|
|
|
|
+ /* the HCD completed the request within the HCD request callback,
|
|
|
|
|
|
+ * check and see if this is a synchronous request */
|
|
|
|
|
|
+ if (pSignal != NULL) {
|
|
|
|
|
|
+ /* it was synchronous */
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Sync-Op signal wait bypassed \n"));
|
|
|
|
|
|
+ /* NULL out completion info, there's no need to
|
|
|
|
|
|
+ * signal the semaphore */
|
|
|
|
|
|
+ pReq->pCompletion = NULL;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Async operation completed in-line \n"));
|
|
|
|
|
|
+ /* this was an async call, always return pending */
|
|
|
|
|
|
+ status = SDIO_STATUS_PENDING;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* process this completed transfer on behalf of the HCD */
|
|
|
|
|
|
+ _SDIO_HandleHcdEvent(pHcd, EVENT_HCD_TRANSFER_DONE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* done processing */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* I/O is now pending, could be sync or async */
|
|
|
|
|
|
+ /* check for synch op */
|
|
|
|
|
|
+ if (pSignal != NULL) {
|
|
|
|
|
|
+ /* wait for completion */
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Sync-Op signal waiting....\n"));
|
|
|
|
|
|
+ /* this is not interruptable, as the HCD must complete it. */
|
|
|
|
|
|
+ status = SignalWait(&pSignal->Signal);
|
|
|
|
|
|
+ /* don't need the signal anymore */
|
|
|
|
|
|
+ FreeSignal(pSignal);
|
|
|
|
|
|
+ pSignal = NULL;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* note: it is safe to touch pReq since we own
|
|
|
|
|
|
+ * the completion routine for synch transfers */
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check signal wait status */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO Bus Driver - IssueRequestToHCD: Synch transfer - signal wait failed, cancelling req 0X%X\n",
|
|
|
|
|
|
+ (UINT)pReq));
|
|
|
|
|
|
+ pReq->Status = SDIO_STATUS_CANCELED;
|
|
|
|
|
|
+ status = SDIO_STATUS_CANCELED;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Sync-Op woke up\n"));
|
|
|
|
|
|
+ /* return the completion status of the request */
|
|
|
|
|
|
+ status = pReq->Status;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Async operation Pending \n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* see if we need to clean up failed submissions */
|
|
|
|
|
|
+ if (handleFailedReqSubmit) {
|
|
|
|
|
|
+ /* make sure this is cleared */
|
|
|
|
|
|
+ AtomicTest_Clear(&pReq->InternalFlags, SDBD_PENDING);
|
|
|
|
|
|
+ /* the request processing failed before it was submitted to the HCD */
|
|
|
|
|
|
+ /* note: since it never made it to the queue we can touch pReq */
|
|
|
|
|
|
+ if (pReq->Flags & SDREQ_FLAGS_TRANS_ASYNC) {
|
|
|
|
|
|
+ /* for ASYNC requests, we need to call the completion routine */
|
|
|
|
|
|
+ DoRequestCompletion(pReq, pHcd);
|
|
|
|
|
|
+ /* return pending for all ASYNC requests */
|
|
|
|
|
|
+ status = SDIO_STATUS_PENDING;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check if we need to clean up the signal */
|
|
|
|
|
|
+ if (pSignal != NULL) {
|
|
|
|
|
|
+ /* make sure this is freed */
|
|
|
|
|
|
+ FreeSignal(pSignal);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* return status */
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* documentation for configuration requests */
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Enable or Disable the SDIO Function
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDCONFIG_FUNC_ENABLE_DISABLE
|
|
|
|
|
|
+ @prototype: SDCONFIG_FUNC_ENABLE_DISABLE
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: SDCONFIG_FUNC_ENABLE_DISABLE_DATA - Enable Data structure
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This command code is used in the SDLIB_IssueConfig() API. The command
|
|
|
|
|
|
+ uses the SDCONFIG_FUNC_ENABLE_DISABLE_DATA structure. The caller must set the
|
|
|
|
|
|
+ EnableFlags and specify the TimeOut value in milliseconds. The TimeOut
|
|
|
|
|
|
+ value is used for polling the I/O ready bit. This command returns a status
|
|
|
|
|
|
+ of SDIO_STATUS_FUNC_ENABLE_TIMEOUT if the ready bit was not set/cleared
|
|
|
|
|
|
+ by the card within the timeout period.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of enabling an I/O function:
|
|
|
|
|
|
+ fData.EnableFlags = SDCONFIG_ENABLE_FUNC;
|
|
|
|
|
|
+ fData.TimeOut = 500;
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pInstance->pDevice,
|
|
|
|
|
|
+ SDCONFIG_FUNC_ENABLE_DISABLE,
|
|
|
|
|
|
+ &fData,
|
|
|
|
|
|
+ sizeof(fData));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Unmask the function's IRQ
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDCONFIG_FUNC_UNMASK_IRQ
|
|
|
|
|
|
+ @prototype: SDCONFIG_FUNC_UNMASK_IRQ
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This command code is used in the SDLIB_IssueConfig() API. The command
|
|
|
|
|
|
+ unmasks the IRQ for the I/O function. This request sets the function's
|
|
|
|
|
|
+ interrupt enable bit in the INTENABLE register in the
|
|
|
|
|
|
+ common register space.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of unmasking interrupt :
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pInstance->pDevice,
|
|
|
|
|
|
+ SDCONFIG_FUNC_UNMASK_IRQ,
|
|
|
|
|
|
+ NULL,
|
|
|
|
|
|
+ 0);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDCONFIG_FUNC_MASK_IRQ
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Mask the function's IRQ
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDCONFIG_FUNC_MASK_IRQ
|
|
|
|
|
|
+ @prototype: SDCONFIG_FUNC_MASK_IRQ
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This command code is used in the SDLIB_IssueConfig() API. The command
|
|
|
|
|
|
+ masks the IRQ for the I/O function.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of unmasking interrupt :
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pInstance->pDevice,
|
|
|
|
|
|
+ SDCONFIG_FUNC_MASK_IRQ,
|
|
|
|
|
|
+ NULL,
|
|
|
|
|
|
+ 0);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDCONFIG_FUNC_UNMASK_IRQ
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Acknowledge that the function's IRQ has been handled
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDCONFIG_FUNC_ACK_IRQ
|
|
|
|
|
|
+ @prototype: SDCONFIG_FUNC_ACK_IRQ
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This command code is used in the SDLIB_IssueConfig() API. The command
|
|
|
|
|
|
+ indicates to the bus driver that the function driver has handled the
|
|
|
|
|
|
+ interrupt. The bus driver will notify the host controller to unmask the
|
|
|
|
|
|
+ interrupt source. SDIO interrupts are level triggered and are masked at the
|
|
|
|
|
|
+ host controller level until all function drivers have indicated that they
|
|
|
|
|
|
+ have handled their respective interrupt. This command can be issued in either
|
|
|
|
|
|
+ the IRQ handler or asynchronous IRQ handler.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of acknowledging an interrupt :
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pInstance->pDevice,
|
|
|
|
|
|
+ SDCONFIG_FUNC_ACK_IRQ,
|
|
|
|
|
|
+ NULL,
|
|
|
|
|
|
+ 0);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Disable SD/MMC/SDIO card CRC checking.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDCONFIG_FUNC_SPI_MODE_DISABLE_CRC
|
|
|
|
|
|
+ @prototype: SDCONFIG_FUNC_SPI_MODE_DISABLE_CRC
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This command code is used in the SDLIB_IssueConfig() API. The command
|
|
|
|
|
|
+ issues CMD59 to disable SPI-CRC checking and requests the host controller
|
|
|
|
|
|
+ driver to stop checking the CRC. This is typically used in systems where
|
|
|
|
|
|
+ CRC checking is not required and performance is improved if the CRC checking
|
|
|
|
|
|
+ is ommitted (i.e. SPI implementations without hardware CRC support).
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of disabling SPI CRC checking:
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pInstance->pDevice,
|
|
|
|
|
|
+ SDCONFIG_FUNC_SPI_MODE_DISABLE_CRC,
|
|
|
|
|
|
+ NULL,
|
|
|
|
|
|
+ 0);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDCONFIG_FUNC_SPI_MODE_ENABLE_CRC
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Enable SD/MMC/SDIO card CRC checking.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDCONFIG_FUNC_SPI_MODE_ENABLE_CRC
|
|
|
|
|
|
+ @prototype: SDCONFIG_FUNC_SPI_MODE_ENABLE_CRC
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This command code is used in the SDLIB_IssueConfig() API. The command
|
|
|
|
|
|
+ issues CMD59 to enable SPI-CRC checking and requests the host controller
|
|
|
|
|
|
+ driver to generate valid CRCs for commands and data as well as
|
|
|
|
|
|
+ check the CRC in responses and incomming data blocks.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of enabling SPI CRC checking:
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pInstance->pDevice,
|
|
|
|
|
|
+ SDCONFIG_FUNC_SPI_MODE_ENABLE_CRC,
|
|
|
|
|
|
+ NULL,
|
|
|
|
|
|
+ 0);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDCONFIG_FUNC_SPI_MODE_DISABLE_CRC
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Allocate slot current for a card function.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDCONFIG_FUNC_ALLOC_SLOT_CURRENT
|
|
|
|
|
|
+ @prototype: SDCONFIG_FUNC_ALLOC_SLOT_CURRENT
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: SDCONFIG_FUNC_SLOT_CURRENT_DATA
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: SDCONFIG_FUNC_SLOT_CURRENT_DATA
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This command code is used in the SDLIB_IssueConfig() API. The command
|
|
|
|
|
|
+ requests an allocation of slot current to satisfy the power requirements
|
|
|
|
|
|
+ of the function. The command uses the SDCONFIG_FUNC_SLOT_CURRENT_DATA
|
|
|
|
|
|
+ data structure to pass the required current in mA. Slot current allocation
|
|
|
|
|
|
+ is not cummulative and this command should only be issued once by each function
|
|
|
|
|
|
+ driver with the worse case slot current usage.
|
|
|
|
|
|
+ The command returns SDIO_STATUS_NO_RESOURCES if the
|
|
|
|
|
|
+ requirement cannot be met by the host hardware. The SlotCurrent field will
|
|
|
|
|
|
+ contain the remaining current available to the slot. The slot current should
|
|
|
|
|
|
+ be allocated before the function is enabled using SDCONFIG_FUNC_ENABLE_DISABLE.
|
|
|
|
|
|
+ When a function driver is unloaded it should free the slot current allocation
|
|
|
|
|
|
+ by using the SDCONFIG_FUNC_FREE_SLOT_CURRENT command.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of allocating slot current:
|
|
|
|
|
|
+ slotCurrent.SlotCurrent = 150; // 150 mA
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pInstance->pDevice,
|
|
|
|
|
|
+ SDCONFIG_FUNC_ALLOC_SLOT_CURRENT,
|
|
|
|
|
|
+ &slotCurrent,
|
|
|
|
|
|
+ sizeof(slotCurrent));
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDCONFIG_FUNC_FREE_SLOT_CURRENT
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Free slot current for a card function.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDCONFIG_FUNC_FREE_SLOT_CURRENT
|
|
|
|
|
|
+ @prototype: SDCONFIG_FUNC_FREE_SLOT_CURRENT
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This command code is used in the SDLIB_IssueConfig() API. The command
|
|
|
|
|
|
+ frees the allocated current for a card function. This command should be
|
|
|
|
|
|
+ issued only once (per function) and only after an allocation was successfully made.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of freeing slot current:
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pInstance->pDevice,
|
|
|
|
|
|
+ SDCONFIG_FUNC_FREE_SLOT_CURRENT,
|
|
|
|
|
|
+ NULL,
|
|
|
|
|
|
+ 0);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDCONFIG_FUNC_ALLOC_SLOT_CURRENT
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Set the bus mode for the SD/SDIO card.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDCONFIG_FUNC_CHANGE_BUS_MODE
|
|
|
|
|
|
+ @prototype: SDCONFIG_FUNC_CHANGE_BUS_MODE
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This command code is used in the SDLIB_IssueConfig() API. The command
|
|
|
|
|
|
+ alters the card's bus mode (width and clock rate) to a driver specified
|
|
|
|
|
|
+ value. The driver must read the current bus mode flags, modify if necessary
|
|
|
|
|
|
+ and pass the value in the SDCONFIG_BUS_MODE_DATA structure.
|
|
|
|
|
|
+ If the bus width is changed (1 or 4 bit) the caller must adjust the mode flags
|
|
|
|
|
|
+ for the new width. Cards cannot be switched between 1/4 bit and SPI mode.
|
|
|
|
|
|
+ Switching to or from SPI mode requires a power cycle. Adjustments to the clock
|
|
|
|
|
|
+ rate is immediate on the next bus transaction. The actual clock rate value is
|
|
|
|
|
|
+ limited by the host controller and is reported in the ClockRate field when the
|
|
|
|
|
|
+ command completes successfully.
|
|
|
|
|
|
+ The bus mode change is card wide and may affect other SDIO functions on
|
|
|
|
|
|
+ multi-function cards. Use this feature with caution. This feature should NOT be
|
|
|
|
|
|
+ used to dynamically control clock rates during runtime and should only be used
|
|
|
|
|
|
+ at card initialization. Changing the bus mode must be done with SDIO function
|
|
|
|
|
|
+ interrupts masked.
|
|
|
|
|
|
+ This request can block and must only be called from a schedulable context.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of changing the clock rate:
|
|
|
|
|
|
+ SDCONFIG_BUS_MODE_DATA busSettings;
|
|
|
|
|
|
+ ZERO_OBJECT(busSettings);
|
|
|
|
|
|
+ // get current bus flags and keep the same bus width
|
|
|
|
|
|
+ busSettings.BusModeFlags = SDDEVICE_GET_BUSMODE_FLAGS(pInstance->pDevice);
|
|
|
|
|
|
+ busSettings.ClockRate = 8000000; // adjust clock to 8 Mhz
|
|
|
|
|
|
+ // issue config request to override clock rate
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pInstance->pDevice,
|
|
|
|
|
|
+ SDCONFIG_FUNC_CHANGE_BUS_MODE,
|
|
|
|
|
|
+ &busSettings,
|
|
|
|
|
|
+ sizeof(SDCONFIG_BUS_MODE_DATA));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_BUSMODE_FLAGS
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the debug level of the underlying host controller driver.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDCONFIG_GET_HCD_DEBUG
|
|
|
|
|
|
+ @prototype: SDCONFIG_GET_HCD_DEBUG
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: CT_DEBUG_LEVEL
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This command code is used in the SDLIB_IssueConfig() API. The command
|
|
|
|
|
|
+ requests the current debug level of the HCD driver. This API is useful for
|
|
|
|
|
|
+ saving the current debug level of the HCD prior to issuing SDCONFIG_SET_HCD_DEBUG
|
|
|
|
|
|
+ in order to increase the verbosity of the HCD. This API should be used only for
|
|
|
|
|
|
+ debugging purposes. If multiple functions attempt to save and set the HCD debug
|
|
|
|
|
|
+ level simultanously, the final debug level will be unknown. Not all HCDs support
|
|
|
|
|
|
+ this command.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of saving the debug level:
|
|
|
|
|
|
+ CT_DEBUG_LEVEL savedDebug;
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pInstance->pDevice,
|
|
|
|
|
|
+ SDCONFIG_GET_HCD_DEBUG,
|
|
|
|
|
|
+ &savedDebug,
|
|
|
|
|
|
+ sizeof(savedDebug));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDCONFIG_SET_HCD_DEBUG
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Set the debug level of the underlying host controller driver.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDCONFIG_SET_HCD_DEBUG
|
|
|
|
|
|
+ @prototype: SDCONFIG_SET_HCD_DEBUG
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: CT_DEBUG_LEVEL
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This command code is used in the SDLIB_IssueConfig() API. The command
|
|
|
|
|
|
+ sets the current debug level of the HCD driver. This API is useful for
|
|
|
|
|
|
+ setting the debug level of the HCD programatically for debugging purposes.
|
|
|
|
|
|
+ If multiple functions attempt to save and set the HCD debug
|
|
|
|
|
|
+ level simultanously, the final debug level will be unknown. Not all HCDs support
|
|
|
|
|
|
+ this request.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of setting the debug level:
|
|
|
|
|
|
+ CT_DEBUG_LEVEL setDebug = 15;
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pInstance->pDevice,
|
|
|
|
|
|
+ SDCONFIG_GET_HCD_DEBUG,
|
|
|
|
|
|
+ &setDebug,
|
|
|
|
|
|
+ sizeof(setDebug));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDCONFIG_GET_HCD_DEBUG
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Instruct the bus driver to not check the SDIO card interrupt pending
|
|
|
|
|
|
+ register on card interrupts, if possible.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDCONFIG_FUNC_NO_IRQ_PEND_CHECK
|
|
|
|
|
|
+ @prototype: SDCONFIG_FUNC_NO_IRQ_PEND_CHECK
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This command code is used in the SDLIB_IssueConfig() API. The command instructs the
|
|
|
|
|
|
+ bus driver to skip checking the card interrupt pending register on each card
|
|
|
|
|
|
+ interrupt. The bus driver will assume the function is interrupting and immediately start
|
|
|
|
|
|
+ the interrupt processing stage. This option is only valid for single function cards.
|
|
|
|
|
|
+ The bus driver will reject the command for a card with more than 1 function.
|
|
|
|
|
|
+ For single function cards, this can improve interrupt response time.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of skipping IRQ pending checks:
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pInstance->pDevice,
|
|
|
|
|
|
+ SDCONFIG_FUNC_NO_IRQ_PEND_CHECK,
|
|
|
|
|
|
+ NULL,
|
|
|
|
|
|
+ 0);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/busdriver/sdio_bus_events.c b/drivers/sdio/stack/busdriver/sdio_bus_events.c
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..5b3148d
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/busdriver/sdio_bus_events.c
|
|
|
|
|
|
@@ -0,0 +1,1040 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: sdio_bus_events.c
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: OS independent bus driver support
|
|
|
|
|
|
+
|
|
|
|
|
|
+#notes: this file contains various event handlers and helpers
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define MODULE_NAME SDBUSDRIVER
|
|
|
|
|
|
+#include <linux/sdio/ctsystem.h>
|
|
|
|
|
|
+#include <linux/sdio/sdio_busdriver.h>
|
|
|
|
|
|
+#include <linux/sdio/sdio_lib.h>
|
|
|
|
|
|
+#include "_busdriver.h"
|
|
|
|
|
|
+#include <linux/sdio/_sdio_defs.h>
|
|
|
|
|
|
+#include <linux/sdio/mmc_defs.h>
|
|
|
|
|
|
+
|
|
|
|
|
|
+static SDIO_STATUS ScanSlotForCard(PSDHCD pHcd,
|
|
|
|
|
|
+ PBOOL pCardPresent);
|
|
|
|
|
|
+static void GetPendingIrqComplete(PSDREQUEST pReq);
|
|
|
|
|
|
+static void ProcessPendingIrqs(PSDHCD pHcd, UINT8 IntPendingMsk);
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * DeviceDetach - tell core a device was removed from a slot
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS DeviceDetach(PSDHCD pHcd)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDCONFIG_SDIO_INT_CTRL_DATA irqData;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ ZERO_OBJECT(irqData);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: DeviceDetach\n"));
|
|
|
|
|
|
+ /* tell any function drivers we are gone */
|
|
|
|
|
|
+ RemoveHcdFunctions(pHcd);
|
|
|
|
|
|
+ /* delete the devices associated with this HCD */
|
|
|
|
|
|
+ DeleteDevices(pHcd);
|
|
|
|
|
|
+ /* check and see if there are any IRQs that were left enabled */
|
|
|
|
|
|
+ if (pHcd->IrqsEnabled) {
|
|
|
|
|
|
+ irqData.SlotIRQEnable = FALSE;
|
|
|
|
|
|
+ /* turn off IRQ detection in HCD */
|
|
|
|
|
|
+ _IssueConfig(pHcd,SDCONFIG_SDIO_INT_CTRL,(PVOID)&irqData, sizeof(irqData));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* reset hcd state */
|
|
|
|
|
|
+ ResetHcdState(pHcd);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("-SDIO Bus Driver: DeviceDetach\n"));
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * DeviceAttach - tell core a device was inserted into a slot
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS DeviceAttach(PSDHCD pHcd)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ PSDDEVICE pDevice = NULL;
|
|
|
|
|
|
+ UINT ii;
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (IS_CARD_PRESENT(pHcd)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: DeviceAttach called on occupied slot!\n"));
|
|
|
|
|
|
+ return SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: DeviceAttach bdctxt:0x%X \n", (UINT32)pBusContext));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (IS_HCD_RAW(pHcd)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: RAW HCD (%s) device attach \n",pHcd->pName));
|
|
|
|
|
|
+ /* this is a raw HCD */
|
|
|
|
|
|
+ memset(&pHcd->CardProperties,0,sizeof(pHcd->CardProperties));
|
|
|
|
|
|
+ pHcd->CardProperties.Flags = CARD_RAW;
|
|
|
|
|
|
+ pHcd->CardProperties.IOFnCount = 0;
|
|
|
|
|
|
+ /* for raw HCD, set up minimum parameters
|
|
|
|
|
|
+ * since we cannot determine these values using any standard, use values
|
|
|
|
|
|
+ * reported by the HCD */
|
|
|
|
|
|
+ /* the operational rate is just the max clock rate reported */
|
|
|
|
|
|
+ pHcd->CardProperties.OperBusClock = pHcd->MaxClockRate;
|
|
|
|
|
|
+ /* the max bytes per data transfer is just the max bytes per block */
|
|
|
|
|
|
+ pHcd->CardProperties.OperBlockLenLimit = pHcd->MaxBytesPerBlock;
|
|
|
|
|
|
+ /* if the raw HCD uses blocks to transfer, report the operational size
|
|
|
|
|
|
+ * from the HCD max value */
|
|
|
|
|
|
+ pHcd->CardProperties.OperBlockCountLimit = pHcd->MaxBlocksPerTrans;
|
|
|
|
|
|
+ /* set the slot preferred voltage */
|
|
|
|
|
|
+ pHcd->CardProperties.CardVoltage = pHcd->SlotVoltagePreferred;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* initialize this card and get card properties */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SDInitializeCard(pHcd)))) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: DeviceAttach, failed to initialize card, %d\n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check for SD or MMC, this must be done first as the query may involve
|
|
|
|
|
|
+ * de-selecting the card */
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ if (!(pHcd->CardProperties.Flags & (CARD_MMC | CARD_SD | CARD_RAW))) {
|
|
|
|
|
|
+ /* none of these were discovered */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ pDevice = AllocateDevice(pHcd);
|
|
|
|
|
|
+ if (NULL == pDevice) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & CARD_RAW) {
|
|
|
|
|
|
+ /* set function number to 1 for IRQ processing */
|
|
|
|
|
|
+ SDDEVICE_SET_SDIO_FUNCNO(pDevice,1);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* get the ID info for the SD/MMC Card */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SDQuerySDMMCInfo(pDevice)))) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: DeviceAttach, query SDMMC Info failed \n"));
|
|
|
|
|
|
+ FreeDevice(pDevice);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ AddDeviceToList(pDevice);
|
|
|
|
|
|
+ /* look for a function driver to handle this card */
|
|
|
|
|
|
+ ProbeForFunction(pDevice, pHcd);
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* create a device for each I/O function */
|
|
|
|
|
|
+ for(ii= 1; ii <= pHcd->CardProperties.IOFnCount; ii++) {
|
|
|
|
|
|
+ pDevice = AllocateDevice(pHcd);
|
|
|
|
|
|
+ if (NULL == pDevice) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* set the function number */
|
|
|
|
|
|
+ SDDEVICE_SET_SDIO_FUNCNO(pDevice,ii);
|
|
|
|
|
|
+ /* get the ID info for each I/O function */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SDQuerySDIOInfo(pDevice)))) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: DeviceAttach, could not query SDIO Info, funcNo:%d status:%d \n",
|
|
|
|
|
|
+ ii, status));
|
|
|
|
|
|
+ FreeDevice(pDevice);
|
|
|
|
|
|
+ /* keep loading other functions */
|
|
|
|
|
|
+ continue;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ AddDeviceToList(pDevice);
|
|
|
|
|
|
+ /* look for a function driver to handle this card */
|
|
|
|
|
|
+ ProbeForFunction(pDevice, pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("-SDIO Bus Driver: DeviceAttach \n"));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE void CompleteRequestCheckCancel(PSDHCD pHcd, PSDREQUEST pReqToComplete)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ BOOL cancel = FALSE;
|
|
|
|
|
|
+ PSDFUNCTION pFunc = NULL;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* handle cancel of current request */
|
|
|
|
|
|
+ if (pReqToComplete->Flags & SDREQ_FLAGS_CANCELED) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver - _SDIO_HandleHcdEvent: cancelling req 0X%X\n", (UINT)pReqToComplete));
|
|
|
|
|
|
+ cancel = TRUE;
|
|
|
|
|
|
+ pReqToComplete->Status = SDIO_STATUS_CANCELED;
|
|
|
|
|
|
+ pFunc = pReqToComplete->pFunction;
|
|
|
|
|
|
+ DBG_ASSERT(pFunc != NULL);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DoRequestCompletion(pReqToComplete, pHcd);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (cancel) {
|
|
|
|
|
|
+ SignalSet(&pFunc->CleanupReqSig);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Indicate to the SDIO bus driver (core) of an event in the host controller
|
|
|
|
|
|
+ driver.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDIO_HandleHcdEvent
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDIO_HandleHcdEvent(PSDHCD pHcd, HCD_EVENT Event)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pHcd - the host controller structure that was registered
|
|
|
|
|
|
+ HCD_EVENT - event code
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes:
|
|
|
|
|
|
+ The host controller driver can indicate asynchronous events by calling this
|
|
|
|
|
|
+ function with an appropriate event code. Refer to the HDK help manual for
|
|
|
|
|
|
+ more information on the event types
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of indicating a card insertion event:
|
|
|
|
|
|
+ SDIO_HandleHcdEvent(&Hcd, EVENT_HCD_ATTACH);
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _SDIO_HandleHcdEvent(PSDHCD pHcd, HCD_EVENT Event)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSDREQUEST pReq;
|
|
|
|
|
|
+ PSDREQUEST pReqToComplete = NULL;
|
|
|
|
|
|
+ PSDREQUEST pNextReq = NULL;
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_HCD_EVENTS, ("SDIO Bus Driver: _SDIO_HandleHcdEvent, event type 0x%X, HCD:0x%X\n",
|
|
|
|
|
|
+ Event, (UINT)pHcd));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (Event == EVENT_HCD_TRANSFER_DONE) {
|
|
|
|
|
|
+ pReq = GET_CURRENT_REQUEST(pHcd);
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ return SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _AcquireHcdLock(pHcd);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* null out the current request */
|
|
|
|
|
|
+ SET_CURRENT_REQUEST(pHcd, NULL);
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: SDIO_HandleHcdEvent Failed to acquire HCD lock \n"));
|
|
|
|
|
|
+ return SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* note: the queue is still marked busy to prevent other threads/tasks from starting
|
|
|
|
|
|
+ * new requests while we are handling completion , some completed requests are
|
|
|
|
|
|
+ * marked as barrier requests which must be handled atomically */
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = pReq->Status;
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS,
|
|
|
|
|
|
+ ("+SDIO Bus Driver: Handling Transfer Done (CMD:%d, Status:%d) from HCD:0x%08X \n",
|
|
|
|
|
|
+ pReq->Command, status, (INT)pHcd));
|
|
|
|
|
|
+ /* check SPI mode conversion */
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd) && SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ if (!(pReq->Flags & SDREQ_FLAGS_RESP_SKIP_SPI_FILT) && !(pReq->Flags & SDREQ_FLAGS_PSEUDO) &&
|
|
|
|
|
|
+ (GET_SDREQ_RESP_TYPE(pReq->Flags) != SDREQ_FLAGS_NO_RESP)) {
|
|
|
|
|
|
+ ConvertSPI_Response(pReq, NULL);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Completing Request:0x%08X \n",(INT)pReq));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status) &&
|
|
|
|
|
|
+ (status != SDIO_STATUS_CANCELED) &&
|
|
|
|
|
|
+ !(pReq->Flags & SDREQ_FLAGS_CANCELED) &&
|
|
|
|
|
|
+ (pReq->RetryCount > 0)) {
|
|
|
|
|
|
+ /* retry the request if it failed, was NOT cancelled and the retry count
|
|
|
|
|
|
+ * is greater than zero */
|
|
|
|
|
|
+ pReq->RetryCount--;
|
|
|
|
|
|
+ pReqToComplete = NULL;
|
|
|
|
|
|
+ /* clear SPI converted flag */
|
|
|
|
|
|
+ pReq->Flags &= ~SDREQ_FLAGS_RESP_SPI_CONVERTED;
|
|
|
|
|
|
+ pNextReq = pReq;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* complete the request */
|
|
|
|
|
|
+ if (pReq->Flags & SDREQ_FLAGS_BARRIER) {
|
|
|
|
|
|
+ /* a barrier request must be completed before the next bus request is
|
|
|
|
|
|
+ * started */
|
|
|
|
|
|
+ CompleteRequestCheckCancel(pHcd, pReq);
|
|
|
|
|
|
+ if (!ForceAllRequestsAsync()) {
|
|
|
|
|
|
+ if (CHECK_API_VERSION_COMPAT(pHcd,2,6)) {
|
|
|
|
|
|
+ /* the request was completed, decrement recursion count */
|
|
|
|
|
|
+ status = _AcquireHcdLock(pHcd);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ pHcd->Recursion--;
|
|
|
|
|
|
+ DBG_ASSERT(pHcd->Recursion >= 0);
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* reset bit */
|
|
|
|
|
|
+ AtomicTest_Clear(&pHcd->HcdFlags, HCD_REQUEST_CALL_BIT);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ pReqToComplete = NULL;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* complete this after the next request has
|
|
|
|
|
|
+ * been started */
|
|
|
|
|
|
+ pReqToComplete = pReq;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* acquire the hcd lock to look at the queues */
|
|
|
|
|
|
+ status = _AcquireHcdLock(pHcd);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ if (pReqToComplete != NULL) {
|
|
|
|
|
|
+ /* queue the request that was completed */
|
|
|
|
|
|
+ QueueRequest(&pHcd->CompletedRequestQueue, pReqToComplete);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (NULL == pNextReq) {
|
|
|
|
|
|
+ /* check the queue for the next request */
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Checking queue.. \n"));
|
|
|
|
|
|
+ /* check to see if the HCD was already working on one. This occurs if
|
|
|
|
|
|
+ * the current request being completed was a barrier request and the
|
|
|
|
|
|
+ * barrier completion routine submitted a new request to the head of the
|
|
|
|
|
|
+ * queue */
|
|
|
|
|
|
+ if (GET_CURRENT_REQUEST(pHcd) == NULL) {
|
|
|
|
|
|
+ pNextReq = DequeueRequest(&pHcd->RequestQueue);
|
|
|
|
|
|
+ if (NULL == pNextReq) {
|
|
|
|
|
|
+ /* nothing in the queue, mark it not busy */
|
|
|
|
|
|
+ MarkQueueNotBusy(&pHcd->RequestQueue);
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Queue idle \n"));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Next request in queue: 0x%X \n",
|
|
|
|
|
|
+ (INT)pNextReq));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS,
|
|
|
|
|
|
+ ("SDIO Bus Driver: Busy Queue from barrier request \n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pNextReq != NULL) {
|
|
|
|
|
|
+ /* a new request will be submitted to the HCD below,
|
|
|
|
|
|
+ * check recursion while we have the lock */
|
|
|
|
|
|
+ if (CHECK_API_VERSION_COMPAT(pHcd,2,6)) {
|
|
|
|
|
|
+ CHECK_HCD_RECURSE(pHcd,pNextReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: SDIO_HandleHcdEvent Failed to acquire HCD lock \n"));
|
|
|
|
|
|
+ return SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* check for the next request to issue */
|
|
|
|
|
|
+ if (pNextReq != NULL) {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("SDIO Bus Driver: Starting Next Request: 0x%X \n",
|
|
|
|
|
|
+ (INT)pNextReq));
|
|
|
|
|
|
+ SET_CURRENT_REQUEST(pHcd,pNextReq);
|
|
|
|
|
|
+ status = CallHcdRequest(pHcd);
|
|
|
|
|
|
+ /* check and see if the HCD completed the request in the callback */
|
|
|
|
|
|
+ if (status != SDIO_STATUS_PENDING) {
|
|
|
|
|
|
+ /* recurse and process the request */
|
|
|
|
|
|
+ _SDIO_HandleHcdEvent(pHcd, EVENT_HCD_TRANSFER_DONE);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* now empty the completed request queue
|
|
|
|
|
|
+ * - this guarantees in-order completion even during recursion */
|
|
|
|
|
|
+ status = _AcquireHcdLock(pHcd);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ while (1) {
|
|
|
|
|
|
+ pReqToComplete = DequeueRequest(&pHcd->CompletedRequestQueue);
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+ if (pReqToComplete != NULL) {
|
|
|
|
|
|
+ CompleteRequestCheckCancel(pHcd, pReqToComplete);
|
|
|
|
|
|
+ if (!CHECK_API_VERSION_COMPAT(pHcd,2,6)) {
|
|
|
|
|
|
+ if (!ForceAllRequestsAsync()) {
|
|
|
|
|
|
+ /* reset bit */
|
|
|
|
|
|
+ AtomicTest_Clear(&pHcd->HcdFlags, HCD_REQUEST_CALL_BIT);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* re-acquire lock */
|
|
|
|
|
|
+ status = _AcquireHcdLock(pHcd);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (CHECK_API_VERSION_COMPAT(pHcd,2,6)) {
|
|
|
|
|
|
+ if (!ForceAllRequestsAsync()) {
|
|
|
|
|
|
+ /* while we have the lock, decrement recursion count each time
|
|
|
|
|
|
+ * we complete a request */
|
|
|
|
|
|
+ pHcd->Recursion--;
|
|
|
|
|
|
+ DBG_ASSERT(pHcd->Recursion >= 0);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* we're done */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: SDIO_HandleHcdEvent Failed to acquire HCD lock \n"));
|
|
|
|
|
|
+ return SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_REQUESTS, ("-SDIO Bus Driver: Transfer Done Handled \n"));
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ switch(Event) {
|
|
|
|
|
|
+ case EVENT_HCD_ATTACH:
|
|
|
|
|
|
+ case EVENT_HCD_DETACH:
|
|
|
|
|
|
+ /* card detect helper does the actual attach detach */
|
|
|
|
|
|
+ return PostCardDetectEvent(pBusContext,Event,pHcd);
|
|
|
|
|
|
+ case EVENT_HCD_SDIO_IRQ_PENDING:
|
|
|
|
|
|
+ return DeviceInterrupt(pHcd);
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("-SDIO Bus Driver: SDIO_HandleHcdEvent, invalid event type 0x%X, HCD:0x%X\n",
|
|
|
|
|
|
+ Event, (UINT)pHcd));
|
|
|
|
|
|
+ return SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* card detect helper function */
|
|
|
|
|
|
+THREAD_RETURN CardDetectHelperFunction(POSKERNEL_HELPER pHelper)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ HCD_EVENT_MESSAGE message;
|
|
|
|
|
|
+ INT length;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver - CardDetectHelperFunction starting up: 0x%X \n", (INT)pHelper));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ while (1) {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* wait for wake up event */
|
|
|
|
|
|
+ status = SD_WAIT_FOR_WAKEUP(pHelper);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver - Card Detect Helper Semaphore Pend Error:%d \n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SD_IS_HELPER_SHUTTING_DOWN(pHelper)) {
|
|
|
|
|
|
+ /* cleanup message queue on shutdown */
|
|
|
|
|
|
+ while (1) {
|
|
|
|
|
|
+ length = sizeof(message);
|
|
|
|
|
|
+ /* get a message */
|
|
|
|
|
|
+ status = SDLIB_GetMessage(pBusContext->pCardDetectMsgQueue,
|
|
|
|
|
|
+ &message, &length);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (message.pHcd != NULL) {
|
|
|
|
|
|
+ /* decrement HCD reference count */
|
|
|
|
|
|
+ OS_DecHcdReference(message.pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ while (1) {
|
|
|
|
|
|
+ length = sizeof(message);
|
|
|
|
|
|
+ /* get a message */
|
|
|
|
|
|
+ status = SDLIB_GetMessage(pBusContext->pCardDetectMsgQueue,
|
|
|
|
|
|
+ &message, &length);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ switch (message.Event) {
|
|
|
|
|
|
+ case EVENT_HCD_ATTACH:
|
|
|
|
|
|
+ DeviceAttach(message.pHcd);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case EVENT_HCD_DETACH:
|
|
|
|
|
|
+ DeviceDetach(message.pHcd);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case EVENT_HCD_CD_POLLING:
|
|
|
|
|
|
+ /* run detector */
|
|
|
|
|
|
+ RunCardDetect();
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (message.pHcd != NULL) {
|
|
|
|
|
|
+ /* message was processed, decrement reference count */
|
|
|
|
|
|
+ OS_DecHcdReference(message.pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver - Card Detect Helper Exiting.. \n"));
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ RunCardDetect - run card detect on host controller slots that require polling
|
|
|
|
|
|
+ Input:
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes: This function is called from the card detect timer thread
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+void RunCardDetect(void)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ BOOL CDPollingRequired = FALSE;
|
|
|
|
|
|
+ PSDLIST pListItem;
|
|
|
|
|
|
+ PSDHCD pHcd;
|
|
|
|
|
|
+ BOOL cardPresent;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_CD_TIMER, ("+SDIO Bus Driver: RunCardDetect\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* protect the HCD list */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(SemaphorePendInterruptable(&pBusContext->HcdListSem))) {
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ return; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* while we are running the detector we are blocking HCD removal*/
|
|
|
|
|
|
+ SDITERATE_OVER_LIST(&pBusContext->HcdList, pListItem) {
|
|
|
|
|
|
+ pHcd = CONTAINING_STRUCT(pListItem, SDHCD, SDList);
|
|
|
|
|
|
+ /* does the HCD require polling ? */
|
|
|
|
|
|
+ if (pHcd->Attributes & SDHCD_ATTRIB_SLOT_POLLING) {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_CD_TIMER, ("SDIO Bus Driver: Found HCD requiring polling \n"));
|
|
|
|
|
|
+ /* set flag to queue the timer */
|
|
|
|
|
|
+ CDPollingRequired = TRUE;
|
|
|
|
|
|
+ if (IS_CARD_PRESENT(pHcd)) {
|
|
|
|
|
|
+ /* there is a device in the slot */
|
|
|
|
|
|
+ cardPresent = TRUE;
|
|
|
|
|
|
+ if (SDIO_SUCCESS(ScanSlotForCard(pHcd,&cardPresent))) {
|
|
|
|
|
|
+ if (!cardPresent) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver CD Polling.. Card Removal Detected\n"));
|
|
|
|
|
|
+ DeviceDetach(pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ cardPresent = FALSE;
|
|
|
|
|
|
+ if (SDIO_SUCCESS(ScanSlotForCard(pHcd,&cardPresent))) {
|
|
|
|
|
|
+ if (cardPresent) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver CD Polling.. Card Detected\n"));
|
|
|
|
|
|
+ DeviceAttach(pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_CD_TIMER, ("SDIO Bus Driver: moving to next hcd:0x%X \n",
|
|
|
|
|
|
+ (INT)pListItem->pNext));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check if we need to queue the timer */
|
|
|
|
|
|
+ if (CDPollingRequired && !pBusContext->CDTimerQueued) {
|
|
|
|
|
|
+ pBusContext->CDTimerQueued = TRUE;
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_CD_TIMER, ("SDIO Bus Driver: Queuing Card detect timer \n"));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(
|
|
|
|
|
|
+ QueueTimer(SDIOBUS_CD_TIMER_ID, pBusContext->CDPollingInterval))) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: failed to queue CD timer \n"));
|
|
|
|
|
|
+ pBusContext->CDTimerQueued = FALSE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* release HCD list lock */
|
|
|
|
|
|
+ SemaphorePost(&pBusContext->HcdListSem);
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_CD_TIMER, ("-SDIO Bus Driver: RunCardDetect\n"));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ ScanSlotForCard - scan slot for a card
|
|
|
|
|
|
+ Input: pHcd - the hcd
|
|
|
|
|
|
+ Output: pCardPresent - card present flag (set/cleared on return)
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static SDIO_STATUS ScanSlotForCard(PSDHCD pHcd,PBOOL pCardPresent)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ UINT8 temp;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_CD_TIMER, ("+SDIO Bus Driver: ScanSlotForCard\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ if (!IS_CARD_PRESENT(pHcd)) {
|
|
|
|
|
|
+ INT dbgLvl;
|
|
|
|
|
|
+ dbgLvl = DBG_GET_DEBUG_LEVEL();
|
|
|
|
|
|
+ DBG_SET_DEBUG_LEVEL(SDDBG_WARN);
|
|
|
|
|
|
+ status = CardInitSetup(pHcd);
|
|
|
|
|
|
+ DBG_SET_DEBUG_LEVEL(dbgLvl);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* issue go-idle */
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ _IssueSimpleBusRequest(pHcd,CMD0,0,SDREQ_FLAGS_RESP_R1,NULL);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ _IssueSimpleBusRequest(pHcd,CMD0,0,SDREQ_FLAGS_NO_RESP,NULL);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* try SDIO */
|
|
|
|
|
|
+ status = TestPresence(pHcd,CARD_SDIO,NULL);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ *pCardPresent = TRUE;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* issue go-idle */
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ _IssueSimpleBusRequest(pHcd,CMD0,0,SDREQ_FLAGS_RESP_R1,NULL);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ _IssueSimpleBusRequest(pHcd,CMD0,0,SDREQ_FLAGS_NO_RESP,NULL);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* try SD */
|
|
|
|
|
|
+ status = TestPresence(pHcd,CARD_SD,NULL);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ *pCardPresent = TRUE;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* issue go-idle */
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ _IssueSimpleBusRequest(pHcd,CMD0,0,SDREQ_FLAGS_RESP_R1,NULL);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ _IssueSimpleBusRequest(pHcd,CMD0,0,SDREQ_FLAGS_NO_RESP,NULL);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* try MMC */
|
|
|
|
|
|
+ status = TestPresence(pHcd,CARD_MMC,NULL);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ *pCardPresent = TRUE;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & CARD_SDIO) {
|
|
|
|
|
|
+#ifdef DUMP_INT_PENDING
|
|
|
|
|
|
+ temp = 0;
|
|
|
|
|
|
+ /* handy debug prints to check interrupt status and print pending register */
|
|
|
|
|
|
+ status = Cmd52ReadByteCommon(pHcd->pPseudoDev, SDIO_INT_ENABLE_REG, &temp);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status) && (temp != 0)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: INT Enable Reg: 0x%2.2X\n", temp));
|
|
|
|
|
|
+ status = Cmd52ReadByteCommon(pHcd->pPseudoDev, SDIO_INT_PENDING_REG, &temp);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: INT Pend Reg: 0x%2.2X\n", temp));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+ /* for SDIO cards, read the revision register */
|
|
|
|
|
|
+ status = Cmd52ReadByteCommon(pHcd->pPseudoDev, CCCR_SDIO_REVISION_REG, &temp);
|
|
|
|
|
|
+ } else if (pHcd->CardProperties.Flags & (CARD_SD | CARD_MMC)) {
|
|
|
|
|
|
+ /* for SD/MMC cards, issue SEND_STATUS */
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ /* SPI uses the SPI R2 response */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,
|
|
|
|
|
|
+ CMD13,
|
|
|
|
|
|
+ 0,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R2,
|
|
|
|
|
|
+ NULL);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,
|
|
|
|
|
|
+ CMD13,
|
|
|
|
|
|
+ (pHcd->CardProperties.RCA << 16),
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1,NULL);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* card is gone */
|
|
|
|
|
|
+ *pCardPresent = FALSE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (status == SDIO_STATUS_BUS_RESP_TIMEOUT) {
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_CD_TIMER, ("-SDIO Bus Driver: ScanSlotForCard status:%d\n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ DeviceInterrupt - handle device interrupt
|
|
|
|
|
|
+ Input: pHcd - host controller
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS DeviceInterrupt(PSDHCD pHcd)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ SDIO_STATUS status2;
|
|
|
|
|
|
+ PSDREQUEST pReq = NULL;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("+SDIO Bus Driver: DeviceInterrupt\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!IS_CARD_PRESENT(pHcd)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("-SDIO Bus Driver: Device interrupt asserted on empty slot!\n"));
|
|
|
|
|
|
+ return SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ /* for RAW HCDs or HCDs flagged for single-function IRQ optimization */
|
|
|
|
|
|
+ if (IS_HCD_RAW(pHcd) || (pHcd->HcdFlags & (1 << HCD_IRQ_NO_PEND_CHECK))) {
|
|
|
|
|
|
+ status = _AcquireHcdLock(pHcd);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (pHcd->IrqProcState != SDHCD_IDLE) {
|
|
|
|
|
|
+ status = SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ status2 = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("SDIO Bus Driver : Device Interrupt \n"));
|
|
|
|
|
|
+ /* mark that we are processing */
|
|
|
|
|
|
+ pHcd->IrqProcState = SDHCD_IRQ_PENDING;
|
|
|
|
|
|
+ status2 = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+ /* process Irqs for raw hcds or HCDs with the single function optimization */
|
|
|
|
|
|
+ /* force processing of function 1 interrupt */
|
|
|
|
|
|
+ ProcessPendingIrqs(pHcd, (1 << 1));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("-SDIO Bus Driver: DeviceInterrupt: %d\n", status));
|
|
|
|
|
|
+ /* done with RAW irqs */
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* pre-allocate a request to get the pending bits, we have to do this outside the
|
|
|
|
|
|
+ * hcd lock acquisition */
|
|
|
|
|
|
+ pReq = AllocateRequest();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _AcquireHcdLock(pHcd);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pHcd->IrqProcState != SDHCD_IDLE) {
|
|
|
|
|
|
+ status = SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* mark that we are processing */
|
|
|
|
|
|
+ pHcd->IrqProcState = SDHCD_IRQ_PENDING;
|
|
|
|
|
|
+ /* build argument to read IRQ pending register */
|
|
|
|
|
|
+ SDIO_SET_CMD52_READ_ARG(pReq->Argument,0,SDIO_INT_PENDING_REG);
|
|
|
|
|
|
+ pReq->Command = CMD52;
|
|
|
|
|
|
+ pReq->Flags = SDREQ_FLAGS_TRANS_ASYNC | SDREQ_FLAGS_RESP_SDIO_R5;
|
|
|
|
|
|
+ pReq->pCompleteContext = (PVOID)pHcd;
|
|
|
|
|
|
+ pReq->pCompletion = GetPendingIrqComplete;
|
|
|
|
|
|
+ pReq->RetryCount = SDBUS_MAX_RETRY;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status2 = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status2)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: lock release error: %d\n", status2));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_ASSERT(pReq != NULL);
|
|
|
|
|
|
+ IssueRequestToHCD(pHcd,pReq);
|
|
|
|
|
|
+ status = SDIO_STATUS_PENDING;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ if (pReq != NULL) {
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("-SDIO Bus Driver: DeviceInterrupt: %d\n", status));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SDIO IRQ helper */
|
|
|
|
|
|
+THREAD_RETURN SDIOIrqHelperFunction(POSKERNEL_HELPER pHelper)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSDHCD pHcd;
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ PSDLIST pListItem;
|
|
|
|
|
|
+ PSDDEVICE pDevice;
|
|
|
|
|
|
+ UINT8 funcMask;
|
|
|
|
|
|
+ PSDDEVICE pDeviceIRQ[7];
|
|
|
|
|
|
+ UINT deviceIrqCount = 0;
|
|
|
|
|
|
+ UINT ii;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver - SDIOIrqHelperFunction starting up \n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pHcd = (PSDHCD)pHelper->pContext;
|
|
|
|
|
|
+ DBG_ASSERT(pHcd != NULL);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ while (1) {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* wait for wake up event */
|
|
|
|
|
|
+ status = SD_WAIT_FOR_WAKEUP(pHelper);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver - SDIOIrqHelperFunction Pend Error:%d \n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SD_IS_HELPER_SHUTTING_DOWN(pHelper)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("SDIO Bus Driver - Pending IRQs:0x%X \n",
|
|
|
|
|
|
+ pHcd->PendingHelperIrqs));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* take the device list lock as we iterate through the list, this blocks
|
|
|
|
|
|
+ * device removals */
|
|
|
|
|
|
+ status = SemaphorePendInterruptable(&pBusContext->DeviceListSem);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* walk through the device list matching HCD and interrupting function */
|
|
|
|
|
|
+ SDITERATE_OVER_LIST(&pBusContext->DeviceList, pListItem) {
|
|
|
|
|
|
+ pDevice = CONTAINING_STRUCT(pListItem, SDDEVICE, SDList);
|
|
|
|
|
|
+ /* check if device belongs to the HCD */
|
|
|
|
|
|
+ if (pDevice->pHcd != pHcd){
|
|
|
|
|
|
+ /* not on this hcd */
|
|
|
|
|
|
+ continue;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ funcMask = 1 << SDDEVICE_GET_SDIO_FUNCNO(pDevice);
|
|
|
|
|
|
+ /* check device function against the pending mask */
|
|
|
|
|
|
+ if (!(funcMask & pHcd->PendingHelperIrqs)) {
|
|
|
|
|
|
+ /* this one is not scheduled for the helper */
|
|
|
|
|
|
+ continue;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* clear bit */
|
|
|
|
|
|
+ pHcd->PendingHelperIrqs &= ~funcMask;
|
|
|
|
|
|
+ /* check for sync IRQ and call handler */
|
|
|
|
|
|
+ if (pDevice->pIrqFunction != NULL) {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("SDIO Bus Driver: Calling IRQ Handler. Fn:%d\n",
|
|
|
|
|
|
+ SDDEVICE_GET_SDIO_FUNCNO(pDevice)));
|
|
|
|
|
|
+ /* save the device so we can process it without holding any locks */
|
|
|
|
|
|
+ pDeviceIRQ[deviceIrqCount++] = pDevice;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* this is actually okay if the device is removing, the callback
|
|
|
|
|
|
+ * is NULLed out */
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("SDIO Bus Driver: No IRQ handler Fn:%d\n",
|
|
|
|
|
|
+ SDDEVICE_GET_SDIO_FUNCNO(pDevice)));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* should have handled all these */
|
|
|
|
|
|
+ DBG_ASSERT(pHcd->PendingHelperIrqs == 0);
|
|
|
|
|
|
+ pHcd->PendingHelperIrqs = 0;
|
|
|
|
|
|
+ SemaphorePost(&pBusContext->DeviceListSem);
|
|
|
|
|
|
+ for (ii = 0; ii < deviceIrqCount; ii++) {
|
|
|
|
|
|
+ /* now call the function */
|
|
|
|
|
|
+ SDDEVICE_CALL_IRQ_HANDLER(pDeviceIRQ[ii]);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ deviceIrqCount = 0;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver - SDIOIrqHelperFunction Exiting.. \n"));
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ GetPendingIrqComplete - completion routine for getting pending IRQs
|
|
|
|
|
|
+ Input: pRequest - completed request
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static void GetPendingIrqComplete(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ UINT8 intPendingMsk;
|
|
|
|
|
|
+ PSDHCD pHcd;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ pHcd = (PSDHCD)pReq->pCompleteContext;
|
|
|
|
|
|
+ DBG_ASSERT(pHcd != NULL);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(pReq->Status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to get Interrupt pending register Err:%d\n",
|
|
|
|
|
|
+ pReq->Status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SD_R5_GET_RESP_FLAGS(pReq->Response) & SD_R5_ERRORS) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: CMD52 resp error: 0x%X \n",
|
|
|
|
|
|
+ SD_R5_GET_RESP_FLAGS(pReq->Response)));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* extract the pending mask */
|
|
|
|
|
|
+ intPendingMsk = SD_R5_GET_READ_DATA(pReq->Response) & SDIO_INT_PEND_MASK;
|
|
|
|
|
|
+ /* process them */
|
|
|
|
|
|
+ ProcessPendingIrqs(pHcd, intPendingMsk);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("-SDIO Bus Driver: GetPendingIrqComplete \n"));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ ProcessPendingIrqs - processing pending Irqs
|
|
|
|
|
|
+ Input: pHcd - host controller
|
|
|
|
|
|
+ Input: IntPendingMsk - pending irq bit mask
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static void ProcessPendingIrqs(PSDHCD pHcd, UINT8 IntPendingMsk)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSDLIST pListItem;
|
|
|
|
|
|
+ PSDDEVICE pDevice;
|
|
|
|
|
|
+ UINT8 funcMask;
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("+SDIO Bus Driver: ProcessPendingIrqs \n"));
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ /* acquire lock to protect configuration and irq enables */
|
|
|
|
|
|
+ status = _AcquireHcdLock(pHcd);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* sanity check */
|
|
|
|
|
|
+ if ((IntPendingMsk & pHcd->IrqsEnabled) != IntPendingMsk) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: IRQs asserting when not enabled : curr:0x%X , card reports: 0x%X\n",
|
|
|
|
|
|
+ pHcd->IrqsEnabled, IntPendingMsk));
|
|
|
|
|
|
+ /* remove the pending IRQs that are not enabled */
|
|
|
|
|
|
+ IntPendingMsk &= pHcd->IrqsEnabled;
|
|
|
|
|
|
+ /* fall through */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!IntPendingMsk) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: No interrupts on HCD:0x%X \n", (INT)pHcd));
|
|
|
|
|
|
+ pHcd->IrqProcState = SDHCD_IDLE;
|
|
|
|
|
|
+ if (pHcd->IrqsEnabled) {
|
|
|
|
|
|
+ /* only re-arm if there are IRQs enabled */
|
|
|
|
|
|
+ _IssueConfig(pHcd,SDCONFIG_SDIO_REARM_INT,NULL,0);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* reset helper IRQ bits */
|
|
|
|
|
|
+ pHcd->PendingHelperIrqs = 0;
|
|
|
|
|
|
+ /* save pending IRQ acks */
|
|
|
|
|
|
+ pHcd->PendingIrqAcks = IntPendingMsk;
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("SDIO Bus Driver: INTs Pending - 0x%2.2X \n", IntPendingMsk));
|
|
|
|
|
|
+ /* take the device list lock as we iterate through the list, this blocks
|
|
|
|
|
|
+ * device removals */
|
|
|
|
|
|
+ status = SemaphorePendInterruptable(&pBusContext->DeviceListSem);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* walk through the device list matching HCD and interrupting function */
|
|
|
|
|
|
+ SDITERATE_OVER_LIST(&pBusContext->DeviceList, pListItem) {
|
|
|
|
|
|
+ pDevice = CONTAINING_STRUCT(pListItem, SDDEVICE, SDList);
|
|
|
|
|
|
+ /* check if device belongs to the HCD */
|
|
|
|
|
|
+ if (pDevice->pHcd != pHcd){
|
|
|
|
|
|
+ /* not on this hcd */
|
|
|
|
|
|
+ continue;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ funcMask = 1 << SDDEVICE_GET_SDIO_FUNCNO(pDevice);
|
|
|
|
|
|
+ /* check device function against the pending mask */
|
|
|
|
|
|
+ if (!(funcMask & IntPendingMsk)) {
|
|
|
|
|
|
+ /* this one is not interrupting */
|
|
|
|
|
|
+ continue;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* check for async IRQ and call handler */
|
|
|
|
|
|
+ if (pDevice->pIrqAsyncFunction != NULL) {
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("SDIO Bus Driver: Calling Async IRQ Handler. Fn:%d\n",
|
|
|
|
|
|
+ SDDEVICE_GET_SDIO_FUNCNO(pDevice)));
|
|
|
|
|
|
+ SDDEVICE_CALL_IRQ_ASYNC_HANDLER(pDevice);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* this one needs the helper */
|
|
|
|
|
|
+ pHcd->PendingHelperIrqs |= funcMask;
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("SDIO Bus Driver: No Async IRQ, Pending Helper Fn:%d\n",
|
|
|
|
|
|
+ SDDEVICE_GET_SDIO_FUNCNO(pDevice)));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* release HCD list lock */
|
|
|
|
|
|
+ SemaphorePost(&pBusContext->DeviceListSem);
|
|
|
|
|
|
+ /* check for helper IRQs */
|
|
|
|
|
|
+ if (pHcd->PendingHelperIrqs) {
|
|
|
|
|
|
+ pHcd->IrqProcState = SDHCD_IRQ_HELPER;
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("SDIO Bus Driver: Waking IRQ Helper \n"));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(SD_WAKE_OS_HELPER(&pHcd->SDIOIrqHelper))) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: failed to wake helper! \n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("-SDIO Bus Driver: ProcessPendingIrqs \n"));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS TryNoIrqPendingCheck(PSDDEVICE pDevice)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ if (pDevice->pHcd->CardProperties.IOFnCount > 1) {
|
|
|
|
|
|
+ /* not supported on multi-function cards */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: IRQ Pending Check cannot be bypassed, (Funcs:%d)\n",
|
|
|
|
|
|
+ pDevice->pHcd->CardProperties.IOFnCount));
|
|
|
|
|
|
+ return SDIO_STATUS_UNSUPPORTED;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: pending IRQ check bypassed \n"));
|
|
|
|
|
|
+ /* set flag to optimize this */
|
|
|
|
|
|
+ AtomicTest_Set(&pDevice->pHcd->HcdFlags, HCD_IRQ_NO_PEND_CHECK);
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ SDIO_NotifyTimerTriggered - notification handler that a timer expired
|
|
|
|
|
|
+ Input: TimerID - ID of timer that expired
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+void SDIO_NotifyTimerTriggered(INT TimerID)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+
|
|
|
|
|
|
+ switch (TimerID) {
|
|
|
|
|
|
+ case SDIOBUS_CD_TIMER_ID:
|
|
|
|
|
|
+ pBusContext->CDTimerQueued = FALSE;
|
|
|
|
|
|
+ /* post an HCD polling event to the helper thread */
|
|
|
|
|
|
+ PostCardDetectEvent(pBusContext, EVENT_HCD_CD_POLLING, NULL);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+}
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/busdriver/sdio_bus_misc.c b/drivers/sdio/stack/busdriver/sdio_bus_misc.c
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..c5c7381
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/busdriver/sdio_bus_misc.c
|
|
|
|
|
|
@@ -0,0 +1,3122 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: sdio_bus_misc.c
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: OS independent bus driver support
|
|
|
|
|
|
+
|
|
|
|
|
|
+#notes: this file contains miscellaneous control functions
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define MODULE_NAME SDBUSDRIVER
|
|
|
|
|
|
+#include <linux/sdio/ctsystem.h>
|
|
|
|
|
|
+#include <linux/sdio/sdio_busdriver.h>
|
|
|
|
|
|
+#include <linux/sdio/sdio_lib.h>
|
|
|
|
|
|
+#include "_busdriver.h"
|
|
|
|
|
|
+#include <linux/sdio/_sdio_defs.h>
|
|
|
|
|
|
+#include <linux/sdio/mmc_defs.h>
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ IssueBusRequestBd - issue a bus request
|
|
|
|
|
|
+ Input: pHcd - HCD object
|
|
|
|
|
|
+ Cmd - command to issue
|
|
|
|
|
|
+ Argument - command argument
|
|
|
|
|
|
+ Flags - request flags
|
|
|
|
|
|
+
|
|
|
|
|
|
+ Output: pReqToUse - request to use (if caller wants response data)
|
|
|
|
|
|
+ Return: SDIO Status
|
|
|
|
|
|
+ Notes: This function only issues 1 block data transfers
|
|
|
|
|
|
+ This function issues the request synchronously
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _IssueBusRequestBd(PSDHCD pHcd,
|
|
|
|
|
|
+ UINT8 Cmd,
|
|
|
|
|
|
+ UINT32 Argument,
|
|
|
|
|
|
+ SDREQUEST_FLAGS Flags,
|
|
|
|
|
|
+ PSDREQUEST pReqToUse,
|
|
|
|
|
|
+ PVOID pData,
|
|
|
|
|
|
+ INT Length)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ PSDREQUEST pReq;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (NULL == pReqToUse) {
|
|
|
|
|
|
+ /* caller doesn't care about the response data, allocate locally */
|
|
|
|
|
|
+ pReq = AllocateRequest();
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ return SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* use the caller's request buffer */
|
|
|
|
|
|
+ pReq = pReqToUse;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pReq->Argument = Argument;
|
|
|
|
|
|
+ pReq->Flags = Flags;
|
|
|
|
|
|
+ pReq->Command = Cmd;
|
|
|
|
|
|
+ if (pReq->Flags & SDREQ_FLAGS_DATA_TRANS) {
|
|
|
|
|
|
+ pReq->pDataBuffer = pData;
|
|
|
|
|
|
+ pReq->BlockCount = 1;
|
|
|
|
|
|
+ pReq->BlockLen = Length;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = IssueRequestToHCD(pHcd,pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (NULL == pReqToUse) {
|
|
|
|
|
|
+ DBG_ASSERT(pReq != NULL);
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ ConvertVoltageCapsToOCRMask - initialize card
|
|
|
|
|
|
+ Input: VoltageCaps - voltage cap to look up
|
|
|
|
|
|
+ Return: 32 bit OCR mask
|
|
|
|
|
|
+ Notes: this function sets voltage for +- 10%
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static UINT32 ConvertVoltageCapsToOCRMask(SLOT_VOLTAGE_MASK VoltageCaps)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ UINT32 ocrMask;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ ocrMask = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (VoltageCaps & SLOT_POWER_3_3V) {
|
|
|
|
|
|
+ ocrMask |= SD_OCR_3_2_TO_3_3_VDD | SD_OCR_3_3_TO_3_4_VDD;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (VoltageCaps & SLOT_POWER_3_0V) {
|
|
|
|
|
|
+ ocrMask |= SD_OCR_2_9_TO_3_0_VDD | SD_OCR_3_0_TO_3_1_VDD;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (VoltageCaps & SLOT_POWER_2_8V) {
|
|
|
|
|
|
+ ocrMask |= SD_OCR_2_7_TO_2_8_VDD | SD_OCR_2_8_TO_2_9_VDD;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (VoltageCaps & SLOT_POWER_2_0V) {
|
|
|
|
|
|
+ ocrMask |= SD_OCR_1_9_TO_2_0_VDD | SD_OCR_2_0_TO_2_1_VDD;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (VoltageCaps & SLOT_POWER_1_8V) {
|
|
|
|
|
|
+ ocrMask |= SD_OCR_1_7_TO_1_8_VDD | SD_OCR_1_8_TO_1_9_VDD;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (VoltageCaps & SLOT_POWER_1_6V) {
|
|
|
|
|
|
+ ocrMask |= SD_OCR_1_6_TO_1_7_VDD;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return ocrMask;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static UINT32 GetUsableOCRValue(UINT32 CardOCR, UINT32 SlotOCRMask)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ INT i;
|
|
|
|
|
|
+ UINT32 mask = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ for (i = 0; i < 32; i++) {
|
|
|
|
|
|
+ mask = 1 << i;
|
|
|
|
|
|
+ if ((SlotOCRMask & mask) && (CardOCR & mask)) {
|
|
|
|
|
|
+ return mask;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return mask;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ GetPowerSetting - power up the SDIO card
|
|
|
|
|
|
+ Input: pHcd - HCD object
|
|
|
|
|
|
+ pOCRvalue - OCR value of the card
|
|
|
|
|
|
+ Output: pOCRvalue - OCR to actually use
|
|
|
|
|
|
+ Return: power setting for HCD based on card's OCR, zero indicates unsupported
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static SLOT_VOLTAGE_MASK GetPowerSetting(PSDHCD pHcd, UINT32 *pOCRvalue)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ UINT32 ocrMask;
|
|
|
|
|
|
+ SLOT_VOLTAGE_MASK hcdVoltage = 0;
|
|
|
|
|
|
+ SLOT_VOLTAGE_MASK hcdVMask;
|
|
|
|
|
|
+ INT i;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check preferred value */
|
|
|
|
|
|
+ ocrMask = ConvertVoltageCapsToOCRMask(pHcd->SlotVoltagePreferred);
|
|
|
|
|
|
+ if (ocrMask & *pOCRvalue) {
|
|
|
|
|
|
+ /* using preferred voltage */
|
|
|
|
|
|
+ *pOCRvalue = GetUsableOCRValue(*pOCRvalue, ocrMask);
|
|
|
|
|
|
+ hcdVoltage = pHcd->SlotVoltagePreferred;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* walk through the slot voltage caps and find a match */
|
|
|
|
|
|
+ for (i = 0; i < 8; i++) {
|
|
|
|
|
|
+ hcdVMask = (1 << i);
|
|
|
|
|
|
+ if (hcdVMask & pHcd->SlotVoltageCaps) {
|
|
|
|
|
|
+ ocrMask = ConvertVoltageCapsToOCRMask((SLOT_VOLTAGE_MASK)(pHcd->SlotVoltageCaps & hcdVMask));
|
|
|
|
|
|
+ if (ocrMask & *pOCRvalue) {
|
|
|
|
|
|
+ /* found a match */
|
|
|
|
|
|
+ *pOCRvalue = GetUsableOCRValue(*pOCRvalue, ocrMask);
|
|
|
|
|
|
+ hcdVoltage = pHcd->SlotVoltageCaps & hcdVMask;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return hcdVoltage;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ TestPresence - test the presence of a card/function
|
|
|
|
|
|
+ Input: pHcd - HCD object
|
|
|
|
|
|
+ TestType - type of test to perform
|
|
|
|
|
|
+ Output: pReq - Request to use (optional)
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS TestPresence(PSDHCD pHcd,
|
|
|
|
|
|
+ CARD_INFO_FLAGS TestType,
|
|
|
|
|
|
+ PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_ERROR;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ switch (TestType) {
|
|
|
|
|
|
+ case CARD_SDIO:
|
|
|
|
|
|
+ /* issue CMD5 */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD5,0,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_SDIO_R4 | SDREQ_FLAGS_RESP_SKIP_SPI_FILT,pReq);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case CARD_SD:
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ /* ACMD41 just starts initialization when in SPI mode, argument is ignored
|
|
|
|
|
|
+ * Note: In SPI mode ACMD41 uses an R1 response */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,ACMD41,0,
|
|
|
|
|
|
+ SDREQ_FLAGS_APP_CMD | SDREQ_FLAGS_RESP_R1,pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* issue ACMD41 with OCR value of zero */
|
|
|
|
|
|
+ /* ACMD41 on SD uses an R3 response */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,ACMD41,0,
|
|
|
|
|
|
+ SDREQ_FLAGS_APP_CMD | SDREQ_FLAGS_RESP_R3,pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case CARD_MMC:
|
|
|
|
|
|
+ /* issue CMD1 */
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ /* note: in SPI mode an R1 response is used */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD1,0,SDREQ_FLAGS_RESP_R1,pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD1,0,SDREQ_FLAGS_RESP_R3,pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ ReadOCR - read the OCR
|
|
|
|
|
|
+ Input: pHcd - HCD object
|
|
|
|
|
|
+ ReadType - type of read to perform
|
|
|
|
|
|
+ OCRValue - OCR value to use as an argument
|
|
|
|
|
|
+ Output: pReq - Request to use
|
|
|
|
|
|
+ pOCRValueRd - OCR value read back (can be NULL)
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static SDIO_STATUS ReadOCR(PSDHCD pHcd,
|
|
|
|
|
|
+ CARD_INFO_FLAGS ReadType,
|
|
|
|
|
|
+ PSDREQUEST pReq,
|
|
|
|
|
|
+ UINT32 OCRValue,
|
|
|
|
|
|
+ UINT32 *pOCRValueRd)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_ERROR;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ switch (ReadType) {
|
|
|
|
|
|
+ case CARD_SDIO:
|
|
|
|
|
|
+ /* CMD5 for SDIO cards */
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ /* skip the SPI filter, we will decode the response here */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD5,
|
|
|
|
|
|
+ OCRValue,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_SDIO_R4 |
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_SKIP_SPI_FILT,
|
|
|
|
|
|
+ pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* native SD */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD5,
|
|
|
|
|
|
+ OCRValue,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_SDIO_R4,
|
|
|
|
|
|
+ pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case CARD_SD:
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ /* CMD58 is used to read the OCR */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD58,
|
|
|
|
|
|
+ 0, /* argument ignored */
|
|
|
|
|
|
+ (SDREQ_FLAGS_RESP_R3 | SDREQ_FLAGS_RESP_SKIP_SPI_FILT),
|
|
|
|
|
|
+ pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* SD Native uses ACMD41 */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,ACMD41,
|
|
|
|
|
|
+ OCRValue,
|
|
|
|
|
|
+ SDREQ_FLAGS_APP_CMD | SDREQ_FLAGS_RESP_R3,
|
|
|
|
|
|
+ pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case CARD_MMC:
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ /* CMD58 is used to read the OCR */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD58,
|
|
|
|
|
|
+ 0, /* argument ignored */
|
|
|
|
|
|
+ (SDREQ_FLAGS_RESP_R3 | SDREQ_FLAGS_RESP_SKIP_SPI_FILT),
|
|
|
|
|
|
+ pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* MMC Native uses CMD1 */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD1,
|
|
|
|
|
|
+ OCRValue, SDREQ_FLAGS_RESP_R3,
|
|
|
|
|
|
+ pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status) && (pOCRValueRd != NULL)) {
|
|
|
|
|
|
+ *pOCRValueRd = 0;
|
|
|
|
|
|
+ /* someone wants the OCR read back */
|
|
|
|
|
|
+ switch (ReadType) {
|
|
|
|
|
|
+ case CARD_SDIO:
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ *pOCRValueRd = SPI_SDIO_R4_GET_OCR(pReq->Response);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ *pOCRValueRd = SD_SDIO_R4_GET_OCR(pReq->Response);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case CARD_SD:
|
|
|
|
|
|
+ case CARD_MMC:
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ *pOCRValueRd = SPI_R3_GET_OCR(pReq->Response);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ *pOCRValueRd = SD_R3_GET_OCR(pReq->Response);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ PollCardReady - poll card till it's ready
|
|
|
|
|
|
+ Input: pHcd - HCD object
|
|
|
|
|
|
+ OCRValue - OCR value to poll with
|
|
|
|
|
|
+ PollType - polling type (based on card type)
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS PollCardReady(PSDHCD pHcd, UINT32 OCRValue, CARD_INFO_FLAGS PollType)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ INT cardReadyRetry;
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ PSDREQUEST pReq;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!((PollType == CARD_SDIO) || (PollType == CARD_SD) || (PollType == CARD_MMC))) {
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ return SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pReq = AllocateRequest();
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ return SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ cardReadyRetry = pBusContext->CardReadyPollingRetry;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Polling card ready, Using OCR:0x%8.8X, Poll Type:0x%X\n",
|
|
|
|
|
|
+ OCRValue,PollType));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* now issue CMD with the actual OCR as an argument until the card is ready */
|
|
|
|
|
|
+ while (cardReadyRetry) {
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd) && !(PollType == CARD_SDIO)) {
|
|
|
|
|
|
+ if (PollType == CARD_MMC) {
|
|
|
|
|
|
+ /* under SPI mode for MMC cards, we need to issue CMD1 and
|
|
|
|
|
|
+ * check the response for the "in-idle" bit */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,
|
|
|
|
|
|
+ CMD1,
|
|
|
|
|
|
+ 0,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1 | SDREQ_FLAGS_RESP_SKIP_SPI_FILT,
|
|
|
|
|
|
+ pReq);
|
|
|
|
|
|
+ } else if (PollType == CARD_SD) {
|
|
|
|
|
|
+ /* under SPI mode for SD cards, we need to issue ACMD41 and
|
|
|
|
|
|
+ * check the response for the "in-idle" bit */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,
|
|
|
|
|
|
+ ACMD41,
|
|
|
|
|
|
+ 0,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1 |
|
|
|
|
|
|
+ SDREQ_FLAGS_APP_CMD |
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_SKIP_SPI_FILT,
|
|
|
|
|
|
+ pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* for SD/MMC in native mode and SDIO (all modes) we need to read the OCR register */
|
|
|
|
|
|
+ /* read the OCR using the supplied OCR value as an argument, we don't care about the
|
|
|
|
|
|
+ * actual OCR read-back, but we are interested in the response */
|
|
|
|
|
|
+ status = ReadOCR(pHcd,PollType,pReq,OCRValue,NULL);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to issue CMD to poll ready \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (PollType == CARD_SDIO) {
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ if (SPI_SDIO_R4_IS_CARD_READY(pReq->Response)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: SDIO Card Ready! (SPI) \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ if (SD_SDIO_R4_IS_CARD_READY(pReq->Response)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: SDIO Card Ready! \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else if ((PollType == CARD_SD) || (PollType == CARD_MMC)) {
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ /* check response when MMC or SD cards operate in SPI mode */
|
|
|
|
|
|
+ if (!(GET_SPI_R1_RESP_TOKEN(pReq->Response) & SPI_CS_STATE_IDLE)) {
|
|
|
|
|
|
+ /* card is no longer in idle */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: SD/MMC Card (SPI mode) is ready! \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* check the OCR busy bit */
|
|
|
|
|
|
+ if (SD_R3_IS_CARD_READY(pReq->Response)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: SD/MMC (Native Mode) Card Ready! \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ cardReadyRetry--;
|
|
|
|
|
|
+ /* delay */
|
|
|
|
|
|
+ status = OSSleep(OCR_READY_CHECK_DELAY_MS);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)){
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (0 == cardReadyRetry) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Card Ready timeout! \n"));
|
|
|
|
|
|
+ status = SDIO_STATUS_DEVICE_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ AdjustSlotPower - adjust slot power
|
|
|
|
|
|
+ Input: pHcd - HCD object
|
|
|
|
|
|
+ Output: pOCRvalue - ocr value to use
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static SDIO_STATUS AdjustSlotPower(PSDHCD pHcd, UINT32 *pOCRvalue)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDCONFIG_POWER_CTRL_DATA pwrSetting;
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ ZERO_OBJECT(pwrSetting);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO Bus Driver: Adjusting Slot Power, Requesting adjustment for OCR:0x%8.8X \n",
|
|
|
|
|
|
+ *pOCRvalue));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ pwrSetting.SlotPowerEnable = TRUE;
|
|
|
|
|
|
+ /* get optimal power setting */
|
|
|
|
|
|
+ pwrSetting.SlotPowerVoltageMask = GetPowerSetting(pHcd, pOCRvalue);
|
|
|
|
|
|
+ if (0 == pwrSetting.SlotPowerVoltageMask) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: No matching voltage for OCR \n"));
|
|
|
|
|
|
+ status = SDIO_STATUS_DEVICE_ERROR;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Slot Pwr Mask 0x%X for OCR:0x%8.8X \n",
|
|
|
|
|
|
+ pwrSetting.SlotPowerVoltageMask,*pOCRvalue));
|
|
|
|
|
|
+ status = _IssueConfig(pHcd,SDCONFIG_POWER_CTRL,&pwrSetting,sizeof(pwrSetting));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to set power in hcd \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* delay for power to settle */
|
|
|
|
|
|
+ OSSleep(pBusContext->PowerSettleDelay);
|
|
|
|
|
|
+ /* save off for drivers */
|
|
|
|
|
|
+ pHcd->CardProperties.CardVoltage = pwrSetting.SlotPowerVoltageMask;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ ConvertEncodedTransSpeed - convert encoded TRANS_SPEED value to a clock rate
|
|
|
|
|
|
+ Input: TransSpeedValue - encoded transfer speed value
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return: appropriate SD clock rate
|
|
|
|
|
|
+ Notes: This function returns a rate of 0, if it could not be determined.
|
|
|
|
|
|
+ This function can check tran speed values for SD,SDIO and MMC cards
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static SD_BUSCLOCK_RATE ConvertEncodedTransSpeed(UINT8 TransSpeedValue)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SD_BUSCLOCK_RATE transfMul = 0;
|
|
|
|
|
|
+ UINT8 timeVal = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ switch (TransSpeedValue & TRANSFER_UNIT_MULTIPIER_MASK) {
|
|
|
|
|
|
+ case 0:
|
|
|
|
|
|
+ transfMul = 10000;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case 1:
|
|
|
|
|
|
+ transfMul = 100000;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case 2:
|
|
|
|
|
|
+ transfMul = 1000000;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case 3:
|
|
|
|
|
|
+ transfMul = 10000000;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ transfMul = 0;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: Card transfer multipler is wrong (val=0x%X)! \n",
|
|
|
|
|
|
+ TransSpeedValue));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ switch ((TransSpeedValue & TIME_VALUE_MASK) >> TIME_VALUE_SHIFT) {
|
|
|
|
|
|
+ case 1: timeVal = 10; break;
|
|
|
|
|
|
+ case 2: timeVal = 12; break;
|
|
|
|
|
|
+ case 3: timeVal = 13; break;
|
|
|
|
|
|
+ case 4: timeVal = 15; break;
|
|
|
|
|
|
+ case 5: timeVal = 20; break;
|
|
|
|
|
|
+ case 6: timeVal = 25; break;
|
|
|
|
|
|
+ case 7: timeVal = 30; break;
|
|
|
|
|
|
+ case 8: timeVal = 35; break;
|
|
|
|
|
|
+ case 9: timeVal = 40; break;
|
|
|
|
|
|
+ case 10: timeVal = 45; break;
|
|
|
|
|
|
+ case 11: timeVal = 50; break;
|
|
|
|
|
|
+ case 12: timeVal = 55; break;
|
|
|
|
|
|
+ case 13: timeVal = 60; break;
|
|
|
|
|
|
+ case 14: timeVal = 70; break;
|
|
|
|
|
|
+ case 15: timeVal = 80; break;
|
|
|
|
|
|
+ default: timeVal = 0;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: Card time value is wrong (val=0x%X)! \n",
|
|
|
|
|
|
+ TransSpeedValue));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if ((transfMul != 0) && (timeVal != 0)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Card Reported Max: %d Hz (0x%X) \n",
|
|
|
|
|
|
+ (timeVal*transfMul), TransSpeedValue));
|
|
|
|
|
|
+ return timeVal*transfMul;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ SelectDeselectCard - Select or deselect a card
|
|
|
|
|
|
+ Input: pHcd - HCD object
|
|
|
|
|
|
+ Select - select the card
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return: status
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static SDIO_STATUS SelectDeselectCard(PSDHCD pHcd, BOOL Select)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ /* SPI mode cards do not support selection */
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ if (!Select) {
|
|
|
|
|
|
+ /* deselect, note that deselecting a card does not return a response */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,
|
|
|
|
|
|
+ CMD7,0,
|
|
|
|
|
|
+ SDREQ_FLAGS_NO_RESP,NULL);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* select */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,
|
|
|
|
|
|
+ CMD7,(pHcd->CardProperties.RCA << 16),
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1B,NULL);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Failed to %s card, RCA:0x%X Err:%d \n",
|
|
|
|
|
|
+ (Select ? "Select":"Deselect"), pHcd->CardProperties.RCA, status));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* reorder a buffer by swapping MSB with LSB */
|
|
|
|
|
|
+static void ReorderBuffer(UINT8 *pBuffer, INT Bytes)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ UINT8 *pEnd;
|
|
|
|
|
|
+ UINT8 temp;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_ASSERT(!(Bytes & 1));
|
|
|
|
|
|
+ /* point to the end */
|
|
|
|
|
|
+ pEnd = &pBuffer[Bytes - 1];
|
|
|
|
|
|
+ /* divide in half */
|
|
|
|
|
|
+ Bytes = Bytes >> 1;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ while (Bytes) {
|
|
|
|
|
|
+ temp = *pBuffer;
|
|
|
|
|
|
+ /* swap bytes */
|
|
|
|
|
|
+ *pBuffer = *pEnd;
|
|
|
|
|
|
+ *pEnd = temp;
|
|
|
|
|
|
+ pBuffer++;
|
|
|
|
|
|
+ pEnd--;
|
|
|
|
|
|
+ Bytes--;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define ADJUST_OPER_CLOCK(pBusMode,Clock) \
|
|
|
|
|
|
+ (pBusMode)->ClockRate = min((SD_BUSCLOCK_RATE)(Clock),(pBusMode)->ClockRate)
|
|
|
|
|
|
+#define ADJUST_OPER_BLOCK_LEN(pCaps,Length) \
|
|
|
|
|
|
+ (pCaps)->OperBlockLenLimit = min((UINT16)(Length),(pCaps)->OperBlockLenLimit)
|
|
|
|
|
|
+#define ADJUST_OPER_BLOCK_COUNT(pCaps,Count) \
|
|
|
|
|
|
+ (pCaps)->OperBlockCountLimit = min((UINT16)(Count),(pCaps)->OperBlockCountLimit)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ GetBusParameters - Get bus parameters for a card
|
|
|
|
|
|
+ Input: pHcd - HCD object
|
|
|
|
|
|
+ pBusMode - current bus mode on entry
|
|
|
|
|
|
+ Output: pBusMode - new adjusted bus mode
|
|
|
|
|
|
+ Return: status
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static SDIO_STATUS GetBusParameters(PSDHCD pHcd, PSDCONFIG_BUS_MODE_DATA pBusMode)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ UINT8 temp;
|
|
|
|
|
|
+ UINT32 tplAddr;
|
|
|
|
|
|
+ struct SDIO_FUNC_EXT_COMMON_TPL func0ext;
|
|
|
|
|
|
+ UINT8 scrRegister[SD_SCR_BYTES];
|
|
|
|
|
|
+ SD_BUSCLOCK_RATE cardReportedRate = 0;
|
|
|
|
|
|
+ PSDREQUEST pReq = NULL;
|
|
|
|
|
|
+ BOOL spiMode = FALSE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDCONFIG_GET_BUSWIDTH(pBusMode->BusModeFlags) == SDCONFIG_BUS_WIDTH_SPI) {
|
|
|
|
|
|
+ spiMode = TRUE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!spiMode) {
|
|
|
|
|
|
+ /* set highest bus mode bus driver is allowing (non-SPI), the code below will
|
|
|
|
|
|
+ * adjust to lower or equal settings */
|
|
|
|
|
|
+ pBusMode->BusModeFlags = pBusContext->DefaultBusMode;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* set operational parameters */
|
|
|
|
|
|
+ pBusMode->ClockRate = pBusContext->DefaultOperClock;
|
|
|
|
|
|
+ pHcd->CardProperties.OperBlockLenLimit = pBusContext->DefaultOperBlockLen;
|
|
|
|
|
|
+ pHcd->CardProperties.OperBlockCountLimit = pBusContext->DefaultOperBlockCount;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* adjust operational block counts and length to match HCD */
|
|
|
|
|
|
+ ADJUST_OPER_BLOCK_LEN(&pHcd->CardProperties,pHcd->MaxBytesPerBlock);
|
|
|
|
|
|
+ ADJUST_OPER_BLOCK_COUNT(&pHcd->CardProperties,pHcd->MaxBlocksPerTrans);
|
|
|
|
|
|
+ /* limit operational clock to the max clock rate */
|
|
|
|
|
|
+ ADJUST_OPER_CLOCK(pBusMode,pHcd->MaxClockRate);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!spiMode) {
|
|
|
|
|
|
+ /* check HCD bus mode */
|
|
|
|
|
|
+ if (!(pHcd->Attributes & SDHCD_ATTRIB_BUS_4BIT) ||
|
|
|
|
|
|
+ ((pHcd->CardProperties.Flags & CARD_SDIO) &&
|
|
|
|
|
|
+ (pHcd->Attributes & SDHCD_ATTRIB_NO_4BIT_IRQ)) ) {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pHcd->Attributes & SDHCD_ATTRIB_BUS_4BIT) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN,
|
|
|
|
|
|
+ ("SDIO Card Detected, but host does not support IRQs in 4 bit mode - dropping to 1 bit. \n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* force to 1 bit mode */
|
|
|
|
|
|
+ SDCONFIG_SET_BUS_WIDTH(pBusMode->BusModeFlags, SDCONFIG_BUS_WIDTH_1_BIT);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* now do various card inquiries to drop the bus mode or clock
|
|
|
|
|
|
+ * none of these checks can raise the bus mode or clock higher that what
|
|
|
|
|
|
+ * was initialized above */
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & (CARD_SD | CARD_MMC)) {
|
|
|
|
|
|
+ /* allocate a request for response data we'll need */
|
|
|
|
|
|
+ pReq = AllocateRequest();
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!spiMode && (pHcd->CardProperties.Flags & CARD_MMC)) {
|
|
|
|
|
|
+ /* MMC cards all run in 1 bit mode */
|
|
|
|
|
|
+ SDCONFIG_SET_BUS_WIDTH(pBusMode->BusModeFlags, SDCONFIG_BUS_WIDTH_1_BIT);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & CARD_SD) {
|
|
|
|
|
|
+ DBG_ASSERT(pReq != NULL);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("Getting SCR from SD Card..\n"));
|
|
|
|
|
|
+ /* read SCR (requires data transfer) to get supported modes */
|
|
|
|
|
|
+ status = _IssueBusRequestBd(pHcd,ACMD51,0,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1 | SDREQ_FLAGS_APP_CMD |
|
|
|
|
|
|
+ SDREQ_FLAGS_DATA_TRANS,
|
|
|
|
|
|
+ pReq,&scrRegister,SD_SCR_BYTES);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SD card does not have SCR. \n"));
|
|
|
|
|
|
+ if (!spiMode) {
|
|
|
|
|
|
+ /* switch it to 1 bit mode */
|
|
|
|
|
|
+ SDCONFIG_SET_BUS_WIDTH(pBusMode->BusModeFlags, SDCONFIG_BUS_WIDTH_1_BIT);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* we have to reorder this buffer since the SCR is sent MSB first on the data
|
|
|
|
|
|
+ * data bus */
|
|
|
|
|
|
+ ReorderBuffer(scrRegister,SD_SCR_BYTES);
|
|
|
|
|
|
+ /* got the SCR */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SD SCR StructRev:0x%X, Flags:0x%X \n",
|
|
|
|
|
|
+ GET_SD_SCR_STRUCT_VER(scrRegister),
|
|
|
|
|
|
+ GET_SD_SCR_BUSWIDTHS_FLAGS(scrRegister)));
|
|
|
|
|
|
+ /* set the revision */
|
|
|
|
|
|
+ switch (GET_SD_SCR_SDSPEC_VER(scrRegister)) {
|
|
|
|
|
|
+ case SCR_SD_SPEC_1_00:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SD Spec Revision 1.01 \n"));
|
|
|
|
|
|
+ pHcd->CardProperties.SD_MMC_Revision = SD_REVISION_1_01;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SCR_SD_SPEC_1_10:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SD Spec Revision 1.10 \n"));
|
|
|
|
|
|
+ pHcd->CardProperties.SD_MMC_Revision = SD_REVISION_1_10;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SD Spec Revision is greater than 1.10 \n"));
|
|
|
|
|
|
+ pHcd->CardProperties.SD_MMC_Revision = SD_REVISION_1_10;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!(GET_SD_SCR_BUSWIDTHS(scrRegister) & SCR_BUS_SUPPORTS_4_BIT)) {
|
|
|
|
|
|
+ if (!spiMode) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SD SCR reports 1bit only Mode \n"));
|
|
|
|
|
|
+ /* switch it to 1 bit mode */
|
|
|
|
|
|
+ SDCONFIG_SET_BUS_WIDTH(pBusMode->BusModeFlags, SDCONFIG_BUS_WIDTH_1_BIT);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & (CARD_SD | CARD_MMC)) {
|
|
|
|
|
|
+ DBG_ASSERT(pReq != NULL);
|
|
|
|
|
|
+ /* de-select the card in order to get the CSD */
|
|
|
|
|
|
+ status = SelectDeselectCard(pHcd,FALSE);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to deselect card before getting CSD \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* Get CSD for SD or MMC cards */
|
|
|
|
|
|
+ if (spiMode) {
|
|
|
|
|
|
+ /* in SPI mode, getting the CSD requires a read data transfer */
|
|
|
|
|
|
+ status = _IssueBusRequestBd(pHcd,CMD9,0,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1 | SDREQ_FLAGS_DATA_TRANS,
|
|
|
|
|
|
+ pReq,
|
|
|
|
|
|
+ pHcd->CardProperties.CardCSD,
|
|
|
|
|
|
+ MAX_CSD_CID_BYTES);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* when the CSD is sent over in SPI data mode, it comes to us in MSB first
|
|
|
|
|
|
+ * and thus is not ordered correctly as defined in the SD spec */
|
|
|
|
|
|
+ ReorderBuffer(pHcd->CardProperties.CardCSD,MAX_CSD_CID_BYTES);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,
|
|
|
|
|
|
+ CMD9,
|
|
|
|
|
|
+ (pHcd->CardProperties.RCA << 16),
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R2,
|
|
|
|
|
|
+ pReq);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* save the CSD */
|
|
|
|
|
|
+ memcpy(pHcd->CardProperties.CardCSD,pReq->Response,MAX_CARD_RESPONSE_BYTES);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to get CSD, Err:%d \n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* for MMC cards, the spec version is in the CSD */
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & CARD_MMC) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("MMC Spec version : (0x%2.2X) \n",
|
|
|
|
|
|
+ GET_MMC_SPEC_VERSION(pHcd->CardProperties.CardCSD)));
|
|
|
|
|
|
+ switch (GET_MMC_SPEC_VERSION(pHcd->CardProperties.CardCSD)) {
|
|
|
|
|
|
+ case MMC_SPEC_1_0_TO_1_2:
|
|
|
|
|
|
+ case MMC_SPEC_1_4:
|
|
|
|
|
|
+ case MMC_SPEC_2_0_TO_2_2:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("MMC Spec version less than 3.1 \n"));
|
|
|
|
|
|
+ pHcd->CardProperties.SD_MMC_Revision = MMC_REVISION_1_0_2_2;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case MMC_SPEC_3_1:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("MMC Spec version 3.1 \n"));
|
|
|
|
|
|
+ pHcd->CardProperties.SD_MMC_Revision = MMC_REVISION_3_1;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case MMC_SPEC_4_0_TO_4_1:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("MMC Spec version 4.0-4.1 \n"));
|
|
|
|
|
|
+ pHcd->CardProperties.SD_MMC_Revision = MMC_REVISION_4_0;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ pHcd->CardProperties.SD_MMC_Revision = MMC_REVISION_3_1;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("MMC Spec version greater than 4.1\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* re-select the card */
|
|
|
|
|
|
+ status = SelectDeselectCard(pHcd,TRUE);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to re-select card after getting CSD \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if ((pHcd->CardProperties.Flags & CARD_SD) &&
|
|
|
|
|
|
+ !(pHcd->CardProperties.Flags & CARD_SDIO) &&
|
|
|
|
|
|
+ SDDEVICE_IS_SD_REV_GTEQ_1_10(pHcd->pPseudoDev) &&
|
|
|
|
|
|
+ (pHcd->Attributes & SDHCD_ATTRIB_SD_HIGH_SPEED) &&
|
|
|
|
|
|
+ !spiMode) {
|
|
|
|
|
|
+ UINT32 arg;
|
|
|
|
|
|
+ PUINT8 pSwitchStatusBlock = KernelAlloc(SD_SWITCH_FUNC_STATUS_BLOCK_BYTES);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (NULL == pSwitchStatusBlock) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ arg = SD_SWITCH_FUNC_ARG_GROUP_CHECK(SD_SWITCH_HIGH_SPEED_GROUP,
|
|
|
|
|
|
+ SD_SWITCH_HIGH_SPEED_FUNC_NO);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* for 1.10 SD cards, check if high speed mode is supported */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Checking SD Card for switchable functions (CMD6 arg:0x%X)\n",arg));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* issue simple data transfer request to read the switch status */
|
|
|
|
|
|
+ status = _IssueBusRequestBd(pHcd,
|
|
|
|
|
|
+ CMD6,
|
|
|
|
|
|
+ arg,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1 | SDREQ_FLAGS_DATA_TRANS,
|
|
|
|
|
|
+ pReq,
|
|
|
|
|
|
+ pSwitchStatusBlock,
|
|
|
|
|
|
+ SD_SWITCH_FUNC_STATUS_BLOCK_BYTES);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ UINT16 switchGroupMask;
|
|
|
|
|
|
+ /* need to reorder this since cards send this MSB first */
|
|
|
|
|
|
+ ReorderBuffer(pSwitchStatusBlock,SD_SWITCH_FUNC_STATUS_BLOCK_BYTES);
|
|
|
|
|
|
+ switchGroupMask = SD_SWITCH_FUNC_STATUS_GET_GRP_BIT_MASK(pSwitchStatusBlock,SD_SWITCH_HIGH_SPEED_GROUP);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SD Card Switch Status Group1 Mask:0x%X Max Current:%d\n",
|
|
|
|
|
|
+ switchGroupMask, SD_SWITCH_FUNC_STATUS_GET_MAX_CURRENT(pSwitchStatusBlock) ));
|
|
|
|
|
|
+ if (SD_SWITCH_FUNC_STATUS_GET_MAX_CURRENT(pSwitchStatusBlock) == 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: SD Switch Status block has zero max current \n"));
|
|
|
|
|
|
+ SDLIB_PrintBuffer(pSwitchStatusBlock,
|
|
|
|
|
|
+ SD_SWITCH_FUNC_STATUS_BLOCK_BYTES,
|
|
|
|
|
|
+ "SDIO Bus Driver: SD Switch Status Block Error");
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* check HS support */
|
|
|
|
|
|
+ if (switchGroupMask & (1 << SD_SWITCH_HIGH_SPEED_FUNC_NO)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SD Card Supports High Speed Mode\n"));
|
|
|
|
|
|
+ /* set the rate, this will override the CSD value */
|
|
|
|
|
|
+ cardReportedRate = SD_HS_MAX_BUS_CLOCK;
|
|
|
|
|
|
+ pBusMode->BusModeFlags |= SDCONFIG_BUS_MODE_SD_HS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to get SD Switch Status block (%d)\n", status));
|
|
|
|
|
|
+ /* just fall through, we'll handle this like a normal SD card */
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ KernelFree(pSwitchStatusBlock);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if ((pHcd->CardProperties.Flags & CARD_MMC) &&
|
|
|
|
|
|
+ SDDEVICE_IS_MMC_REV_GTEQ_4_0(pHcd->pPseudoDev) &&
|
|
|
|
|
|
+ (pHcd->Attributes & SDHCD_ATTRIB_MMC_HIGH_SPEED) &&
|
|
|
|
|
|
+ !spiMode) {
|
|
|
|
|
|
+ /* for MMC cards, get the Extended CSD to get the High speed and
|
|
|
|
|
|
+ * wide bus paramaters */
|
|
|
|
|
|
+
|
|
|
|
|
|
+ PUINT8 pExtData = KernelAlloc(MMC_EXT_CSD_SIZE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (NULL == pExtData) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* issue simple data transfer request to read the extended CSD */
|
|
|
|
|
|
+ status = _IssueBusRequestBd(pHcd,MMC_CMD8,0,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1 | SDREQ_FLAGS_DATA_TRANS,
|
|
|
|
|
|
+ pReq,
|
|
|
|
|
|
+ pExtData,
|
|
|
|
|
|
+ MMC_EXT_CSD_SIZE);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("MMC Ext CSD Version: 0x%X Card Type: 0x%X\n",
|
|
|
|
|
|
+ pExtData[MMC_EXT_VER_OFFSET],pExtData[MMC_EXT_CARD_TYPE_OFFSET]));
|
|
|
|
|
|
+ /* check HS support */
|
|
|
|
|
|
+ if (pExtData[MMC_EXT_CARD_TYPE_OFFSET] & MMC_EXT_CARD_TYPE_HS_52) {
|
|
|
|
|
|
+ /* try 52 Mhz */
|
|
|
|
|
|
+ cardReportedRate = 52000000;
|
|
|
|
|
|
+ pBusMode->BusModeFlags |= SDCONFIG_BUS_MODE_MMC_HS;
|
|
|
|
|
|
+ } else if (pExtData[MMC_EXT_CARD_TYPE_OFFSET] & MMC_EXT_CARD_TYPE_HS_26) {
|
|
|
|
|
|
+ /* try 26MHZ */
|
|
|
|
|
|
+ cardReportedRate = 26000000;
|
|
|
|
|
|
+ pBusMode->BusModeFlags |= SDCONFIG_BUS_MODE_MMC_HS;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* doesn't report high speed capable */
|
|
|
|
|
|
+ cardReportedRate = 0;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (cardReportedRate && !spiMode) {
|
|
|
|
|
|
+ /* figure out the bus mode */
|
|
|
|
|
|
+ if (pHcd->Attributes & SDHCD_ATTRIB_BUS_MMC8BIT) {
|
|
|
|
|
|
+ SDCONFIG_SET_BUS_WIDTH(pBusMode->BusModeFlags, SDCONFIG_BUS_WIDTH_MMC8_BIT);
|
|
|
|
|
|
+ } else if (pHcd->Attributes & SDHCD_ATTRIB_BUS_4BIT) {
|
|
|
|
|
|
+ SDCONFIG_SET_BUS_WIDTH(pBusMode->BusModeFlags, SDCONFIG_BUS_WIDTH_4_BIT);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* we leave it to default to 1 bit mode */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to get MMC Extended CSD \n"));
|
|
|
|
|
|
+ /* just fall through, we'll do without the extended information
|
|
|
|
|
|
+ * and run it like a legacy MMC card */
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ KernelFree(pExtData);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & (CARD_SD | CARD_MMC)) {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (0 == cardReportedRate) {
|
|
|
|
|
|
+ /* extract rate from CSD only if it was not set by earlier tests */
|
|
|
|
|
|
+ cardReportedRate = ConvertEncodedTransSpeed(
|
|
|
|
|
|
+ GET_SD_CSD_TRANS_SPEED(pHcd->CardProperties.CardCSD));
|
|
|
|
|
|
+ /* fall through and test for zero again */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (cardReportedRate != 0) {
|
|
|
|
|
|
+ /* adjust clock based on what the card can handle */
|
|
|
|
|
|
+ ADJUST_OPER_CLOCK(pBusMode,cardReportedRate);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* something is wrong with the CSD */
|
|
|
|
|
|
+ if (DBG_GET_DEBUG_LEVEL() >= SDDBG_TRACE) {
|
|
|
|
|
|
+ SDLIB_PrintBuffer(pHcd->CardProperties.CardCSD,
|
|
|
|
|
|
+ MAX_CARD_RESPONSE_BYTES,
|
|
|
|
|
|
+ "SDIO Bus Driver: CSD Dump");
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* can't figure out the card rate, so set reasonable defaults */
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & CARD_SD) {
|
|
|
|
|
|
+ ADJUST_OPER_CLOCK(pBusMode,SD_MAX_BUS_CLOCK);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ ADJUST_OPER_CLOCK(pBusMode,MMC_MAX_BUS_CLOCK);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* note, we do SDIO card "after" SD in case this is a combo card */
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & CARD_SDIO) {
|
|
|
|
|
|
+ /* read card capabilities */
|
|
|
|
|
|
+ status = Cmd52ReadByteCommon(pHcd->pPseudoDev,
|
|
|
|
|
|
+ SDIO_CARD_CAPS_REG,
|
|
|
|
|
|
+ &pHcd->CardProperties.SDIOCaps);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Card Caps: 0x%X \n",pHcd->CardProperties.SDIOCaps));
|
|
|
|
|
|
+ if (pHcd->CardProperties.SDIOCaps & SDIO_CAPS_LOW_SPEED) {
|
|
|
|
|
|
+ /* adjust max clock for LS device */
|
|
|
|
|
|
+ ADJUST_OPER_CLOCK(pBusMode,SDIO_LOW_SPEED_MAX_BUS_CLOCK);
|
|
|
|
|
|
+ /* adjust bus if LS device does not support 4 bit mode */
|
|
|
|
|
|
+ if (!(pHcd->CardProperties.SDIOCaps & SDIO_CAPS_4BIT_LS)) {
|
|
|
|
|
|
+ if (!spiMode) {
|
|
|
|
|
|
+ /* low speed device does not support 4 bit mode, force us to 1 bit */
|
|
|
|
|
|
+ SDCONFIG_SET_BUS_WIDTH(pBusMode->BusModeFlags,
|
|
|
|
|
|
+ SDCONFIG_BUS_WIDTH_1_BIT);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check if 1.2 card supports high speed mode, checking HCD as well*/
|
|
|
|
|
|
+ if (SDDEVICE_IS_SDIO_REV_GTEQ_1_20(pHcd->pPseudoDev) &&
|
|
|
|
|
|
+ (pHcd->Attributes & SDHCD_ATTRIB_SD_HIGH_SPEED) &&
|
|
|
|
|
|
+ !spiMode) {
|
|
|
|
|
|
+ UCHAR hsControl = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = Cmd52ReadByteCommon(pHcd->pPseudoDev,
|
|
|
|
|
|
+ SDIO_HS_CONTROL_REG,
|
|
|
|
|
|
+ &hsControl);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO Failed to read high speed control (%d) \n",status));
|
|
|
|
|
|
+ /* reset status and continue */
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ if (hsControl & SDIO_HS_CONTROL_SHS) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Card Supports High Speed Mode\n"));
|
|
|
|
|
|
+ pBusMode->BusModeFlags |= SDCONFIG_BUS_MODE_SD_HS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ cardReportedRate = 0;
|
|
|
|
|
|
+ temp = sizeof(func0ext);
|
|
|
|
|
|
+ tplAddr = pHcd->CardProperties.CommonCISPtr;
|
|
|
|
|
|
+ /* get the FUNCE tuple */
|
|
|
|
|
|
+ status = SDLIB_FindTuple(pHcd->pPseudoDev,
|
|
|
|
|
|
+ CISTPL_FUNCE,
|
|
|
|
|
|
+ &tplAddr,
|
|
|
|
|
|
+ (PUINT8)&func0ext,
|
|
|
|
|
|
+ &temp);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status) || (temp < sizeof(func0ext))) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Function 0 Ext. Tuple Missing (Got size:%d) \n", temp));
|
|
|
|
|
|
+ /* reset status */
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* convert encoded value to rate */
|
|
|
|
|
|
+ cardReportedRate = ConvertEncodedTransSpeed(func0ext.MaxTransSpeed);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (cardReportedRate != 0) {
|
|
|
|
|
|
+ if (pBusMode->BusModeFlags & SDCONFIG_BUS_MODE_SD_HS) {
|
|
|
|
|
|
+ if (cardReportedRate <= SD_MAX_BUS_CLOCK) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN,
|
|
|
|
|
|
+ ("SDIO Function tuple reports clock:%d Hz, with advertised High Speed support \n", cardReportedRate));
|
|
|
|
|
|
+ /* back off high speed support */
|
|
|
|
|
|
+ pBusMode->BusModeFlags &= ~SDCONFIG_BUS_MODE_SD_HS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ if (cardReportedRate > SD_MAX_BUS_CLOCK) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN,
|
|
|
|
|
|
+ ("SDIO Function tuple reports clock:%d Hz, without advertising High Speed support..using 25Mhz \n", cardReportedRate));
|
|
|
|
|
|
+ cardReportedRate = SD_MAX_BUS_CLOCK;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* adjust clock based on what the card can handle */
|
|
|
|
|
|
+ ADJUST_OPER_CLOCK(pBusMode,cardReportedRate);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* set a reasonable default */
|
|
|
|
|
|
+ ADJUST_OPER_CLOCK(pBusMode,SD_MAX_BUS_CLOCK);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pReq != NULL) {
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ SetOperationalBusMode - set operational bus mode
|
|
|
|
|
|
+ Input: pDevice - pDevice that is requesting the change
|
|
|
|
|
|
+ pBusMode - operational bus mode
|
|
|
|
|
|
+ Output: pBusMode - on return will have the actual clock rate set
|
|
|
|
|
|
+ Return: status
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS SetOperationalBusMode(PSDDEVICE pDevice,
|
|
|
|
|
|
+ PSDCONFIG_BUS_MODE_DATA pBusMode)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ UCHAR regData;
|
|
|
|
|
|
+ UINT32 arg;
|
|
|
|
|
|
+ UINT32 switcharg;
|
|
|
|
|
|
+ PSDHCD pHcd = pDevice->pHcd;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* synchronize access for updating bus mode settings */
|
|
|
|
|
|
+ status = SemaphorePendInterruptable(&pDevice->pHcd->ConfigureOpsSem);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!IS_CARD_PRESENT(pHcd)) {
|
|
|
|
|
|
+ /* for an empty slot (a Pseudo dev was passed in) we still allow the
|
|
|
|
|
|
+ * bus mode to be set for the card detect
|
|
|
|
|
|
+ * polling */
|
|
|
|
|
|
+ status = _IssueConfig(pHcd,SDCONFIG_BUS_MODE_CTRL,pBusMode,sizeof(SDCONFIG_BUS_MODE_DATA));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to set bus mode in hcd : Err:%d \n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* nothing more to do */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if ((pBusMode->BusModeFlags == SDDEVICE_GET_BUSMODE_FLAGS(pDevice)) &&
|
|
|
|
|
|
+ (pBusMode->ClockRate == SDDEVICE_GET_OPER_CLOCK(pDevice))) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO Bus Driver: Bus mode already set, nothing to do\n"));
|
|
|
|
|
|
+ pBusMode->ActualClockRate = SDDEVICE_GET_OPER_CLOCK(pDevice);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pBusMode->BusModeFlags & SDCONFIG_BUS_MODE_MMC_HS) {
|
|
|
|
|
|
+ if (!(pHcd->Attributes & SDHCD_ATTRIB_MMC_HIGH_SPEED)) {
|
|
|
|
|
|
+ status = SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: HCD does not support MMC High Speed\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pBusMode->BusModeFlags & SDCONFIG_BUS_MODE_SD_HS) {
|
|
|
|
|
|
+ if (!(pHcd->Attributes & SDHCD_ATTRIB_SD_HIGH_SPEED)) {
|
|
|
|
|
|
+ status = SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: HCD does not support SD High Speed\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* before we set the operational clock and mode, configure the clock for high
|
|
|
|
|
|
+ * speed mode on the card , if necessary */
|
|
|
|
|
|
+ if ((pHcd->CardProperties.Flags & CARD_MMC) &&
|
|
|
|
|
|
+ (pBusMode->BusModeFlags & SDCONFIG_BUS_MODE_MMC_HS) &&
|
|
|
|
|
|
+ !(SDDEVICE_GET_BUSMODE_FLAGS(pDevice) & SDCONFIG_BUS_MODE_MMC_HS)) {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ switcharg = MMC_SWITCH_BUILD_ARG(MMC_SWITCH_CMD_SET0,
|
|
|
|
|
|
+ MMC_SWITCH_WRITE_BYTE,
|
|
|
|
|
|
+ MMC_EXT_HS_TIMING_OFFSET,
|
|
|
|
|
|
+ MMC_EXT_HS_TIMING_ENABLE);
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,
|
|
|
|
|
|
+ MMC_CMD_SWITCH,
|
|
|
|
|
|
+ switcharg,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1B,
|
|
|
|
|
|
+ NULL);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: Failed to switch MMC High Speed Mode (arg:0x%X): %d \n",
|
|
|
|
|
|
+ switcharg, status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: High Speed MMC enabled (arg:0x%X)\n",
|
|
|
|
|
|
+ switcharg));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* before setting bus mode and clock in the HCD, switch card to high speed mode
|
|
|
|
|
|
+ * if necessary */
|
|
|
|
|
|
+ if ((pHcd->CardProperties.Flags & CARD_SD) &&
|
|
|
|
|
|
+ (pBusMode->BusModeFlags & SDCONFIG_BUS_MODE_SD_HS) &&
|
|
|
|
|
|
+ !(SDDEVICE_GET_BUSMODE_FLAGS(pDevice) & SDCONFIG_BUS_MODE_SD_HS)) {
|
|
|
|
|
|
+ UINT32 arg;
|
|
|
|
|
|
+ PUINT8 pSwitchStatusBlock;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pSwitchStatusBlock = KernelAlloc(SD_SWITCH_FUNC_STATUS_BLOCK_BYTES);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (NULL == pSwitchStatusBlock) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* set high speed group */
|
|
|
|
|
|
+ arg = SD_SWITCH_FUNC_ARG_GROUP_SET(SD_SWITCH_HIGH_SPEED_GROUP,
|
|
|
|
|
|
+ SD_SWITCH_HIGH_SPEED_FUNC_NO);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Setting SD Card for High Speed mode (CMD6 arg:0x%X)\n",arg));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* issue simple data transfer request to switch modes */
|
|
|
|
|
|
+ status = _IssueBusRequestBd(pHcd,
|
|
|
|
|
|
+ CMD6,
|
|
|
|
|
|
+ arg,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1 | SDREQ_FLAGS_DATA_TRANS,
|
|
|
|
|
|
+ NULL,
|
|
|
|
|
|
+ pSwitchStatusBlock,
|
|
|
|
|
|
+ SD_SWITCH_FUNC_STATUS_BLOCK_BYTES);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ ReorderBuffer(pSwitchStatusBlock,SD_SWITCH_FUNC_STATUS_BLOCK_BYTES);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: SD High Speed Result, Got Max Current:%d mA, SwitchResult:0x%X \n",
|
|
|
|
|
|
+ SD_SWITCH_FUNC_STATUS_GET_MAX_CURRENT(pSwitchStatusBlock),
|
|
|
|
|
|
+ SDSwitchGetSwitchResult(pSwitchStatusBlock, SD_SWITCH_HIGH_SPEED_GROUP)));
|
|
|
|
|
|
+ if (SD_SWITCH_FUNC_STATUS_GET_MAX_CURRENT(pSwitchStatusBlock) == 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Error in Status Block after High Speed Switch (current==0) \n"));
|
|
|
|
|
|
+ status = SDIO_STATUS_DEVICE_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SDSwitchGetSwitchResult(pSwitchStatusBlock, SD_SWITCH_HIGH_SPEED_GROUP) !=
|
|
|
|
|
|
+ SD_SWITCH_HIGH_SPEED_FUNC_NO) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: Error in Status Block after High Speed Switch (Group1 did not switch) \n"));
|
|
|
|
|
|
+ status = SDIO_STATUS_DEVICE_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: SD High Speed Mode Enabled \n"));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ SDLIB_PrintBuffer(pSwitchStatusBlock,
|
|
|
|
|
|
+ SD_SWITCH_FUNC_STATUS_BLOCK_BYTES,
|
|
|
|
|
|
+ "SDIO Bus Driver: SD Switch Status Block Error");
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to Set SD High Speed Mode (%d) \n",status));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ KernelFree(pSwitchStatusBlock);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* enable/disable high speed mode for SDIO card */
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & CARD_SDIO) {
|
|
|
|
|
|
+ BOOL doSet = TRUE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if ((pBusMode->BusModeFlags & SDCONFIG_BUS_MODE_SD_HS) &&
|
|
|
|
|
|
+ !(SDDEVICE_GET_BUSMODE_FLAGS(pDevice) & SDCONFIG_BUS_MODE_SD_HS)) {
|
|
|
|
|
|
+ /* enable */
|
|
|
|
|
|
+ regData = SDIO_HS_CONTROL_EHS;
|
|
|
|
|
|
+ } else if (!(pBusMode->BusModeFlags & SDCONFIG_BUS_MODE_SD_HS) &&
|
|
|
|
|
|
+ (SDDEVICE_GET_BUSMODE_FLAGS(pDevice) & SDCONFIG_BUS_MODE_SD_HS)) {
|
|
|
|
|
|
+ /* disable */
|
|
|
|
|
|
+ regData = 0;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* do nothing */
|
|
|
|
|
|
+ doSet = FALSE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (doSet) {
|
|
|
|
|
|
+ status = Cmd52WriteByteCommon(pDevice,
|
|
|
|
|
|
+ SDIO_HS_CONTROL_REG,
|
|
|
|
|
|
+ ®Data);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to %s HS mode in SDIO card : Err:%d\n",
|
|
|
|
|
|
+ (SDIO_HS_CONTROL_EHS == regData) ? "enable":"disable" , status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver:SDIO Card %s for High Speed mode \n",
|
|
|
|
|
|
+ (SDIO_HS_CONTROL_EHS == regData) ? "enabled":"disabled" ));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* use synchronize-with-bus request version, this may have been requested by a
|
|
|
|
|
|
+ * function driver */
|
|
|
|
|
|
+ status = SDLIB_IssueConfig(pDevice,
|
|
|
|
|
|
+ SDCONFIG_BUS_MODE_CTRL,
|
|
|
|
|
|
+ pBusMode,
|
|
|
|
|
|
+ sizeof(SDCONFIG_BUS_MODE_DATA));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to set bus mode in hcd : Err:%d \n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check requested bus width against the current mode */
|
|
|
|
|
|
+ if (SDCONFIG_GET_BUSWIDTH(pBusMode->BusModeFlags) ==
|
|
|
|
|
|
+ SDCONFIG_GET_BUSWIDTH(pHcd->CardProperties.BusMode)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Bus mode set, no width change\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDCONFIG_GET_BUSWIDTH(pBusMode->BusModeFlags) == SDCONFIG_BUS_WIDTH_SPI) {
|
|
|
|
|
|
+ /* nothing more to do for SPI */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* set the bus width for SD and combo cards */
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & CARD_SD) {
|
|
|
|
|
|
+ if (SDCONFIG_GET_BUSWIDTH(pBusMode->BusModeFlags) == SDCONFIG_BUS_WIDTH_4_BIT) {
|
|
|
|
|
|
+ /* turn off card detect resistor */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,
|
|
|
|
|
|
+ ACMD42,
|
|
|
|
|
|
+ 0, /* disable CD */
|
|
|
|
|
|
+ SDREQ_FLAGS_APP_CMD | SDREQ_FLAGS_RESP_R1,
|
|
|
|
|
|
+ NULL);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: Failed to disable CD Res: %d \n",
|
|
|
|
|
|
+ status)); /* this should be okay */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ arg = SD_ACMD6_BUS_WIDTH_4_BIT;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* don't need to turn off CD in 1 bit mode, just set mode */
|
|
|
|
|
|
+ arg = SD_ACMD6_BUS_WIDTH_1_BIT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* set the bus width */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,
|
|
|
|
|
|
+ ACMD6,
|
|
|
|
|
|
+ arg, /* set bus mode */
|
|
|
|
|
|
+ SDREQ_FLAGS_APP_CMD | SDREQ_FLAGS_RESP_R1,
|
|
|
|
|
|
+ NULL);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to set bus width: %d \n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* set bus width for SDIO cards */
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & CARD_SDIO) {
|
|
|
|
|
|
+ /* default */
|
|
|
|
|
|
+ regData = CARD_DETECT_DISABLE | SDIO_BUS_WIDTH_1_BIT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDCONFIG_GET_BUSWIDTH(pBusMode->BusModeFlags) == SDCONFIG_BUS_WIDTH_4_BIT) {
|
|
|
|
|
|
+ /* turn off card detect resistor and set buswidth */
|
|
|
|
|
|
+ regData = CARD_DETECT_DISABLE | SDIO_BUS_WIDTH_4_BIT;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Enabling 4 bit mode on card \n"));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Enabling 1 bit mode on card \n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = Cmd52WriteByteCommon(pDevice,
|
|
|
|
|
|
+ SDIO_BUS_IF_REG,
|
|
|
|
|
|
+ ®Data);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to set bus mode in Card : Err:%d\n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check for 4-bit interrupt detect mode */
|
|
|
|
|
|
+ if ((SDCONFIG_GET_BUSWIDTH(pBusMode->BusModeFlags) == SDCONFIG_BUS_WIDTH_4_BIT) &&
|
|
|
|
|
|
+ (pHcd->CardProperties.SDIOCaps & SDIO_CAPS_INT_MULTI_BLK) &&
|
|
|
|
|
|
+ (pHcd->Attributes & SDHCD_ATTRIB_MULTI_BLK_IRQ)) {
|
|
|
|
|
|
+ /* enable interrupts between blocks, this doesn't actually turn on interrupts
|
|
|
|
|
|
+ * it merely allows interrupts to be asserted in the inter-block gap */
|
|
|
|
|
|
+ pHcd->CardProperties.SDIOCaps |= SDIO_CAPS_ENB_INT_MULTI_BLK;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: 4-Bit Multi-blk Interrupt support enabled\n"));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* make sure this is disabled */
|
|
|
|
|
|
+ pHcd->CardProperties.SDIOCaps &= ~SDIO_CAPS_ENB_INT_MULTI_BLK;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = Cmd52WriteByteCommon(pDevice,
|
|
|
|
|
|
+ SDIO_CARD_CAPS_REG,
|
|
|
|
|
|
+ &pHcd->CardProperties.SDIOCaps);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to update Card Caps register Err:%d\n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* set data bus width for MMC */
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & CARD_MMC) {
|
|
|
|
|
|
+ UINT8 buswidth = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDCONFIG_GET_BUSWIDTH(pBusMode->BusModeFlags) == SDCONFIG_BUS_WIDTH_4_BIT) {
|
|
|
|
|
|
+ buswidth = MMC_EXT_BUS_WIDTH_4_BIT;
|
|
|
|
|
|
+ } else if (SDCONFIG_GET_BUSWIDTH(pBusMode->BusModeFlags) == SDCONFIG_BUS_WIDTH_MMC8_BIT) {
|
|
|
|
|
|
+ buswidth = MMC_EXT_BUS_WIDTH_8_BIT;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* normal 1 bit mode .. nothing to do */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* now set the bus mode on the card */
|
|
|
|
|
|
+ switcharg = MMC_SWITCH_BUILD_ARG(MMC_SWITCH_CMD_SET0,
|
|
|
|
|
|
+ MMC_SWITCH_WRITE_BYTE,
|
|
|
|
|
|
+ MMC_EXT_BUS_WIDTH_OFFSET,
|
|
|
|
|
|
+ buswidth);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,
|
|
|
|
|
|
+ MMC_CMD_SWITCH,
|
|
|
|
|
|
+ switcharg,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1B,
|
|
|
|
|
|
+ NULL);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to set MMC bus width (arg:0x%X): %d \n",
|
|
|
|
|
|
+ switcharg, status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDCONFIG_GET_BUSWIDTH(pBusMode->BusModeFlags) == SDCONFIG_BUS_WIDTH_4_BIT) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: 4 bit MMC mode enabled (arg:0x%X) \n",
|
|
|
|
|
|
+ switcharg));
|
|
|
|
|
|
+ } else if (SDCONFIG_GET_BUSWIDTH(pBusMode->BusModeFlags) == SDCONFIG_BUS_WIDTH_MMC8_BIT) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: 8-Bit MMC mode enabled (arg:0x%X) \n",
|
|
|
|
|
|
+ switcharg));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* set the operating mode */
|
|
|
|
|
|
+ pHcd->CardProperties.BusMode = pBusMode->BusModeFlags;
|
|
|
|
|
|
+ /* set the actual clock rate */
|
|
|
|
|
|
+ pHcd->CardProperties.OperBusClock = pBusMode->ActualClockRate;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ SemaphorePost(&pDevice->pHcd->ConfigureOpsSem);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ CardInitSetup - setup host for card initialization
|
|
|
|
|
|
+ Input: pHcd - HCD object
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS CardInitSetup(PSDHCD pHcd)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDCONFIG_INIT_CLOCKS_DATA initClocks;
|
|
|
|
|
|
+ SDCONFIG_BUS_MODE_DATA busMode;
|
|
|
|
|
|
+ UINT32 OCRvalue;
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ ZERO_OBJECT(initClocks);
|
|
|
|
|
|
+ ZERO_OBJECT(busMode);
|
|
|
|
|
|
+ /* setup defaults */
|
|
|
|
|
|
+ initClocks.NumberOfClocks = SDMMC_MIN_INIT_CLOCKS;
|
|
|
|
|
|
+ busMode.ClockRate = SD_INIT_BUS_CLOCK;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check for SPI only */
|
|
|
|
|
|
+ if (pHcd->Attributes & SDHCD_ATTRIB_BUS_SPI) {
|
|
|
|
|
|
+ /* SPI cards startup in non-CRC mode with the exception of CMD0, the
|
|
|
|
|
|
+ * HCDs must issue CMD0 with the correct CRC , the spec shows that a
|
|
|
|
|
|
+ * CMD 0 sequence is 0x40,0x00,0x00,0x00,0x00,0x95 */
|
|
|
|
|
|
+ busMode.BusModeFlags = SDCONFIG_BUS_WIDTH_SPI | SDCONFIG_BUS_MODE_SPI_NO_CRC;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* check if host supports 1 bit mode */
|
|
|
|
|
|
+ /* TODO : if host supports power switching, we can
|
|
|
|
|
|
+ * could initialize cards in SPI mode first */
|
|
|
|
|
|
+ if (pHcd->Attributes & SDHCD_ATTRIB_BUS_1BIT) {
|
|
|
|
|
|
+ busMode.BusModeFlags = SDCONFIG_BUS_WIDTH_1_BIT;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* set initial VDD, starting at the highest allowable voltage and working
|
|
|
|
|
|
+ * our way down */
|
|
|
|
|
|
+ if (pHcd->SlotVoltageCaps & SLOT_POWER_3_3V) {
|
|
|
|
|
|
+ OCRvalue = SD_OCR_3_2_TO_3_3_VDD;
|
|
|
|
|
|
+ } else if (pHcd->SlotVoltageCaps & SLOT_POWER_3_0V) {
|
|
|
|
|
|
+ OCRvalue = SD_OCR_2_9_TO_3_0_VDD;
|
|
|
|
|
|
+ } else if (pHcd->SlotVoltageCaps & SLOT_POWER_2_8V) {
|
|
|
|
|
|
+ OCRvalue = SD_OCR_2_7_TO_2_8_VDD;
|
|
|
|
|
|
+ } else if (pHcd->SlotVoltageCaps & SLOT_POWER_2_0V) {
|
|
|
|
|
|
+ OCRvalue = SD_OCR_1_9_TO_2_0_VDD;
|
|
|
|
|
|
+ } else if (pHcd->SlotVoltageCaps & SLOT_POWER_1_8V) {
|
|
|
|
|
|
+ OCRvalue = SD_OCR_1_7_TO_1_8_VDD;
|
|
|
|
|
|
+ } else if (pHcd->SlotVoltageCaps & SLOT_POWER_1_6V) {
|
|
|
|
|
|
+ OCRvalue = SD_OCR_1_6_TO_1_7_VDD;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ OCRvalue = 0;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ /* power up the card */
|
|
|
|
|
|
+ status = AdjustSlotPower(pHcd, &OCRvalue);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to adjust slot power \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = SetOperationalBusMode(pHcd->pPseudoDev,&busMode);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to set bus mode \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = _IssueConfig(pHcd,SDCONFIG_SEND_INIT_CLOCKS,&initClocks,sizeof(initClocks));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to send init clocks in hcd \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while(FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ SDInitializeCard - initialize card
|
|
|
|
|
|
+ Input: pHcd - HCD object
|
|
|
|
|
|
+ Output: pProperties - card properties
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS SDInitializeCard(PSDHCD pHcd)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDCONFIG_BUS_MODE_DATA busMode;
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ PSDREQUEST pReq = NULL;
|
|
|
|
|
|
+ UINT32 OCRvalue;
|
|
|
|
|
|
+ UINT32 tplAddr;
|
|
|
|
|
|
+ UINT8 temp;
|
|
|
|
|
|
+ struct SDIO_MANFID_TPL manfid;
|
|
|
|
|
|
+ SDCONFIG_WP_VALUE wpValue;
|
|
|
|
|
|
+ UINT8 cisBuffer[3];
|
|
|
|
|
|
+
|
|
|
|
|
|
+ OCRvalue = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Initializing card in SPI mode \n"));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Initializing card in MMC/SD mode \n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pReq = AllocateRequest();
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: failed to allocate bus request \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ memset(pReq, 0, sizeof(SDREQUEST));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CardInitSetup(pHcd);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to setup card \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = _IssueConfig(pHcd,SDCONFIG_GET_WP,&wpValue,sizeof(wpValue));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: host doesn't support Write Protect \n"));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ if (wpValue) {
|
|
|
|
|
|
+ pHcd->CardProperties.Flags |= CARD_SD_WP;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: SD WP switch is on \n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!(pHcd->Attributes & SDHCD_ATTRIB_SLOT_POLLING) &&
|
|
|
|
|
|
+ IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ /* for non-slot polling HCDs operating in SPI mode
|
|
|
|
|
|
+ * issue CMD0 to reset card state and to place the card
|
|
|
|
|
|
+ * in SPI mode. If slot polling is used, the polling thread
|
|
|
|
|
|
+ * will have already issued a CMD0 to place the card in SPI mode*/
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ INT ii = 256;
|
|
|
|
|
|
+ status = SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ /* if the CMD0 fails, retry it. Some cards have a hard time getting into SPI mode.*/
|
|
|
|
|
|
+ while ((!SDIO_SUCCESS(status)) && (ii-- >= 0)) {
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD0,0,SDREQ_FLAGS_RESP_R1,pReq);
|
|
|
|
|
|
+ OSSleep(20);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: cmd0 go SPI retries:(256) %d\n", ii));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD0,0,SDREQ_FLAGS_NO_RESP,pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: go-idle failed! \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Looking for SDIO.. \n"));
|
|
|
|
|
|
+ /* check for SDIO card by trying to read it's OCR */
|
|
|
|
|
|
+ status = ReadOCR(pHcd,CARD_SDIO,pReq,0,&OCRvalue);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* we got a response, this is an SDIO card */
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ /* handle SPI */
|
|
|
|
|
|
+ pHcd->CardProperties.IOFnCount = SPI_SDIO_R4_GET_IO_FUNC_COUNT(pReq->Response);
|
|
|
|
|
|
+ if (SPI_SDIO_R4_IS_MEMORY_PRESENT(pReq->Response)) {
|
|
|
|
|
|
+ /* flag an SD function exists */
|
|
|
|
|
|
+ pHcd->CardProperties.Flags |= CARD_SD;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* handle native SD */
|
|
|
|
|
|
+ pHcd->CardProperties.IOFnCount = SD_SDIO_R4_GET_IO_FUNC_COUNT(pReq->Response);
|
|
|
|
|
|
+ if (SD_SDIO_R4_IS_MEMORY_PRESENT(pReq->Response)) {
|
|
|
|
|
|
+ /* flag an SD function exists */
|
|
|
|
|
|
+ pHcd->CardProperties.Flags |= CARD_SD;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (0 == pHcd->CardProperties.IOFnCount) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: SDIO Card reports no functions \n"));
|
|
|
|
|
|
+ status = SDIO_STATUS_DEVICE_ERROR;
|
|
|
|
|
|
+ pHcd->CardProperties.Flags = 0;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ pHcd->CardProperties.Flags |= CARD_SDIO;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO Bus Driver: SDIO Card, Functions: %d Card Info Flags:0x%X OCR:0x%8.8X\n",
|
|
|
|
|
|
+ pHcd->CardProperties.IOFnCount, pHcd->CardProperties.Flags, OCRvalue));
|
|
|
|
|
|
+ /* adjust slot power for this SDIO card */
|
|
|
|
|
|
+ status = AdjustSlotPower(pHcd, &OCRvalue);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to set power in hcd \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* poll for SDIO card ready */
|
|
|
|
|
|
+ status = PollCardReady(pHcd,OCRvalue,CARD_SDIO);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else if (status != SDIO_STATUS_BUS_RESP_TIMEOUT){
|
|
|
|
|
|
+ /* major error in hcd, bail */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check if this is an SDIO-only card before continuing */
|
|
|
|
|
|
+ if (!(pHcd->CardProperties.Flags & CARD_SD) && (pHcd->CardProperties.Flags & CARD_SDIO)) {
|
|
|
|
|
|
+ /* this is an SDIO card with no memory function */
|
|
|
|
|
|
+ goto prepareCard;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!(pHcd->CardProperties.Flags & CARD_SDIO)) {
|
|
|
|
|
|
+ /* issue go idle only if we did not find an SDIO function in our earlier test */
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD0,0,SDREQ_FLAGS_RESP_R1,pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD0,0,SDREQ_FLAGS_NO_RESP,pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: go-idle failed! \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Looking for SD Memory.. \n"));
|
|
|
|
|
|
+ /* SD Memory Card checking */
|
|
|
|
|
|
+ /* test for present of SD card (stand-alone or combo card) */
|
|
|
|
|
|
+ status = TestPresence(pHcd, CARD_SD, pReq);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* there is an SD Card present, could be part of a combo system */
|
|
|
|
|
|
+ pHcd->CardProperties.Flags |= CARD_SD;
|
|
|
|
|
|
+ if (0 == OCRvalue) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: SD Memory card detected. \n"));
|
|
|
|
|
|
+ /* no OCR value on entry this is a stand-alone card, go and get it*/
|
|
|
|
|
|
+ status = ReadOCR(pHcd,CARD_SD,pReq,0,&OCRvalue);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status) || (OCRvalue == 0)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to get OCR (status:%d) \n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: SD Card Reports OCR:0x%8.8X \n", OCRvalue));
|
|
|
|
|
|
+ status = AdjustSlotPower(pHcd, &OCRvalue);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to adjust power \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_ASSERT((pHcd->CardProperties.Flags & (CARD_SD | CARD_SDIO)));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: SDIO Combo Card detected \n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* poll for SD card ready */
|
|
|
|
|
|
+ status = PollCardReady(pHcd,OCRvalue,CARD_SD);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* check if this card has an SDIO function */
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & CARD_SDIO) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: Combo Detected but SD memory function failed \n"));
|
|
|
|
|
|
+ /* allow SDIO functions to load normally */
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ /* remove SD flag */
|
|
|
|
|
|
+ pHcd->CardProperties.Flags &= ~CARD_SD;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: SD Memory ready. \n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* we're done, no need to check for MMC */
|
|
|
|
|
|
+ goto prepareCard;
|
|
|
|
|
|
+ } else if (status != SDIO_STATUS_BUS_RESP_TIMEOUT){
|
|
|
|
|
|
+ /* major error in hcd, bail */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* MMC card checking */
|
|
|
|
|
|
+ /* if we get here, these better not be set */
|
|
|
|
|
|
+ DBG_ASSERT(!(pHcd->CardProperties.Flags & (CARD_SD | CARD_SDIO)));
|
|
|
|
|
|
+ /* issue go idle */
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD0,0,SDREQ_FLAGS_RESP_R1,pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD0,0,SDREQ_FLAGS_NO_RESP,pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: go-idle failed! \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Looking for MMC.. \n"));
|
|
|
|
|
|
+ status = TestPresence(pHcd, CARD_MMC, pReq);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: unknown card detected \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: MMC Card Detected \n"));
|
|
|
|
|
|
+ pHcd->CardProperties.Flags |= CARD_MMC;
|
|
|
|
|
|
+ /* read the OCR value */
|
|
|
|
|
|
+ status = ReadOCR(pHcd,CARD_MMC,pReq,0,&OCRvalue);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status) || (OCRvalue == 0)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Failed to get OCR (status:%d)",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: MMC Card Reports OCR:0x%8.8X \n", OCRvalue));
|
|
|
|
|
|
+ /* adjust power */
|
|
|
|
|
|
+ status = AdjustSlotPower(pHcd, &OCRvalue);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to adjust power \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* poll for MMC card ready */
|
|
|
|
|
|
+ status = PollCardReady(pHcd,OCRvalue,CARD_MMC);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* fall through and prepare MMC card */
|
|
|
|
|
|
+
|
|
|
|
|
|
+prepareCard:
|
|
|
|
|
|
+ /* we're done figuring out what was inserted, and setting up
|
|
|
|
|
|
+ * optimal slot voltage, now we need to prepare the card */
|
|
|
|
|
|
+ if (!IS_HCD_BUS_MODE_SPI(pHcd) &&
|
|
|
|
|
|
+ (pHcd->CardProperties.Flags & (CARD_SD | CARD_MMC))) {
|
|
|
|
|
|
+ /* non-SPI SD or MMC cards need to be moved to the "ident" state before we can get the
|
|
|
|
|
|
+ * RCA or select the card using the new RCA */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD2,0,SDREQ_FLAGS_RESP_R2,pReq);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)){
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: failed to move SD/MMC card into ident state \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ /* non-SPI mode cards need their RCA's setup */
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & (CARD_SD | CARD_SDIO)) {
|
|
|
|
|
|
+ /* issue CMD3 to get RCA on SD/SDIO cards */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,CMD3,0,SDREQ_FLAGS_RESP_R6,pReq);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)){
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: failed to get RCA for SD/SDIO card \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ pHcd->CardProperties.RCA = SD_R6_GET_RCA(pReq->Response);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: SD/SDIO RCA:0x%X \n",
|
|
|
|
|
|
+ pHcd->CardProperties.RCA));
|
|
|
|
|
|
+ } else if (pHcd->CardProperties.Flags & CARD_MMC) {
|
|
|
|
|
|
+ /* for MMC cards, we have to assign a relative card address */
|
|
|
|
|
|
+ /* just a non-zero number */
|
|
|
|
|
|
+ pHcd->CardProperties.RCA = 1;
|
|
|
|
|
|
+ /* issue CMD3 to set the RCA for MMC cards */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pHcd,
|
|
|
|
|
|
+ CMD3,(pHcd->CardProperties.RCA << 16),
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1,pReq);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)){
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: failed to set RCA for MMC card! (err=%d) \n",status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* select the card in order to get the rest of the card info, applies
|
|
|
|
|
|
+ * to SDIO/SD/MMC cards*/
|
|
|
|
|
|
+ status = SelectDeselectCard(pHcd, TRUE);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: failed to select card! \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver, Card now Selected.. \n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pHcd->CardProperties.Flags & CARD_SDIO) {
|
|
|
|
|
|
+ /* read SDIO revision register */
|
|
|
|
|
|
+ status = Cmd52ReadByteCommon(pHcd->pPseudoDev, CCCR_SDIO_REVISION_REG, &temp);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Revision Reg: 0x%X \n", temp));
|
|
|
|
|
|
+ switch (temp & SDIO_REV_MASK) {
|
|
|
|
|
|
+ case SDIO_REV_1_00:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Spec Revision 1.00 \n"));
|
|
|
|
|
|
+ pHcd->CardProperties.SDIORevision = SDIO_REVISION_1_00;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDIO_REV_1_10:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Spec Revision 1.10 \n"));
|
|
|
|
|
|
+ pHcd->CardProperties.SDIORevision = SDIO_REVISION_1_10;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDIO_REV_1_20:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Spec Revision 1.20 \n"));
|
|
|
|
|
|
+ pHcd->CardProperties.SDIORevision = SDIO_REVISION_1_20;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Warning: unknown SDIO revision, treating like 1.0 device \n"));
|
|
|
|
|
|
+ pHcd->CardProperties.SDIORevision = SDIO_REVISION_1_00;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* get the common CIS ptr */
|
|
|
|
|
|
+ status = Cmd52ReadMultipleCommon(pHcd->pPseudoDev,
|
|
|
|
|
|
+ SDIO_CMN_CIS_PTR_LOW_REG,
|
|
|
|
|
|
+ cisBuffer,
|
|
|
|
|
|
+ 3);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to get CIS ptr, Err:%d", status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* this is endian-safe*/
|
|
|
|
|
|
+ pHcd->CardProperties.CommonCISPtr = ((UINT32)cisBuffer[0]) |
|
|
|
|
|
|
+ (((UINT32)cisBuffer[1]) << 8) |
|
|
|
|
|
|
+ (((UINT32)cisBuffer[2]) << 16);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Card CIS Ptr: 0x%X \n", pHcd->CardProperties.CommonCISPtr));
|
|
|
|
|
|
+ temp = sizeof(manfid);
|
|
|
|
|
|
+ tplAddr = pHcd->CardProperties.CommonCISPtr;
|
|
|
|
|
|
+ /* get the MANFID tuple */
|
|
|
|
|
|
+ status = SDLIB_FindTuple(pHcd->pPseudoDev,
|
|
|
|
|
|
+ CISTPL_MANFID,
|
|
|
|
|
|
+ &tplAddr,
|
|
|
|
|
|
+ (PUINT8)&manfid,
|
|
|
|
|
|
+ &temp);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: Failed to get MANFID tuple err:%d \n", status));
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* save this off so that it can be copied into each SDIO Func's SDDEVICE structure */
|
|
|
|
|
|
+ pHcd->CardProperties.SDIO_ManufacturerCode =
|
|
|
|
|
|
+ CT_LE16_TO_CPU_ENDIAN(manfid.ManufacturerCode);
|
|
|
|
|
|
+ pHcd->CardProperties.SDIO_ManufacturerID =
|
|
|
|
|
|
+ CT_LE16_TO_CPU_ENDIAN(manfid.ManufacturerInfo);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO MANFID:0x%X, MANFINFO:0x%X \n",
|
|
|
|
|
|
+ pHcd->CardProperties.SDIO_ManufacturerID,
|
|
|
|
|
|
+ pHcd->CardProperties.SDIO_ManufacturerCode));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pHcd->CardProperties.SDIORevision >= SDIO_REVISION_1_10) {
|
|
|
|
|
|
+ /* read power control */
|
|
|
|
|
|
+ status = Cmd52ReadByteCommon(pHcd->pPseudoDev, SDIO_POWER_CONTROL_REG, &temp);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* check for power control support which indicates the card may use more
|
|
|
|
|
|
+ * than 200 mA */
|
|
|
|
|
|
+ if (temp & SDIO_POWER_CONTROL_SMPC) {
|
|
|
|
|
|
+ /* check that the host can support this. */
|
|
|
|
|
|
+ if (pHcd->MaxSlotCurrent >= SDIO_EMPC_CURRENT_THRESHOLD) {
|
|
|
|
|
|
+ temp = SDIO_POWER_CONTROL_EMPC;
|
|
|
|
|
|
+ /* enable power control on the card */
|
|
|
|
|
|
+ status = Cmd52WriteByteCommon(pHcd->pPseudoDev, SDIO_POWER_CONTROL_REG, &temp);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Busdriver: failed to enable power control (%d) \n",status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* mark that the card is high power */
|
|
|
|
|
|
+ pHcd->CardProperties.Flags |= CARD_HIPWR;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO Busdriver: Power Control Enabled on SDIO (1.10 or greater) card \n"));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN,
|
|
|
|
|
|
+ ("SDIO Busdriver: Card can operate higher than 200mA, host cannot (max:%d) \n",
|
|
|
|
|
|
+ pHcd->MaxSlotCurrent));
|
|
|
|
|
|
+ /* this is not fatal, the card should operate at a reduced rate */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO Busdriver: SDIO 1.10 (or greater) card draws less than 200mA \n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN,
|
|
|
|
|
|
+ ("SDIO Busdriver: failed to get POWER CONTROL REG (%d) \n",status));
|
|
|
|
|
|
+ /* fall through and continue on at reduced mode */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* get the current bus parameters */
|
|
|
|
|
|
+ busMode.BusModeFlags = pHcd->CardProperties.BusMode;
|
|
|
|
|
|
+ busMode.ClockRate = pHcd->CardProperties.OperBusClock;
|
|
|
|
|
|
+ /* get the rest of the bus parameters like clock and supported bus width */
|
|
|
|
|
|
+ status = GetBusParameters(pHcd,&busMode);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ /* check HCD if it wants to run without SPI CRC */
|
|
|
|
|
|
+ if (pHcd->Attributes & SDHCD_ATTRIB_NO_SPI_CRC) {
|
|
|
|
|
|
+ /* hcd would rather not run with CRC we don't need to tell the card since SPI mode
|
|
|
|
|
|
+ * cards power up with CRC initially disabled */
|
|
|
|
|
|
+ busMode.BusModeFlags |= SDCONFIG_BUS_MODE_SPI_NO_CRC;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* first enable SPI CRC checking if the HCD can handle it */
|
|
|
|
|
|
+ status = SDSPIModeEnableDisableCRC(pHcd->pPseudoDev, TRUE);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: Failed to set Enable SPI CRC on card \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = SetOperationalBusMode(pHcd->pPseudoDev, &busMode);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to set operational bus mode\n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Oper. Mode: Clock:%d, Bus:0x%X \n",
|
|
|
|
|
|
+ pHcd->CardProperties.OperBusClock,pHcd->CardProperties.BusMode));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Card in TRANS state, Ready: CardInfo Flags 0x%X \n",
|
|
|
|
|
|
+ pHcd->CardProperties.Flags));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pReq != NULL) {
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ SDQuerySDMMCInfo - query MMC card info
|
|
|
|
|
|
+ Input: pDevice - device
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS SDQuerySDMMCInfo(PSDDEVICE pDevice)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ PSDREQUEST pReq = NULL;
|
|
|
|
|
|
+ UINT8 CID[MAX_CSD_CID_BYTES];
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ pReq = AllocateRequest();
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* de-select the card */
|
|
|
|
|
|
+ status = SelectDeselectCard(pDevice->pHcd,FALSE);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to deselect card before getting CID \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SDDEVICE_IS_BUSMODE_SPI(pDevice)) {
|
|
|
|
|
|
+ /* in SPI mode, getting the CSD requires a data transfer */
|
|
|
|
|
|
+ status = _IssueBusRequestBd(pDevice->pHcd,CMD10,0,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1 | SDREQ_FLAGS_DATA_TRANS,
|
|
|
|
|
|
+ pReq,
|
|
|
|
|
|
+ CID,
|
|
|
|
|
|
+ MAX_CSD_CID_BYTES);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* in SPI mode we need to reorder to the CID since SPI data comes in MSB first*/
|
|
|
|
|
|
+ ReorderBuffer(CID,MAX_CSD_CID_BYTES);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* get the CID */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pDevice->pHcd,
|
|
|
|
|
|
+ CMD10,
|
|
|
|
|
|
+ (SDDEVICE_GET_CARD_RCA(pDevice) << 16),
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R2,
|
|
|
|
|
|
+ pReq);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* extract it from the reponse */
|
|
|
|
|
|
+ memcpy(CID,pReq->Response,MAX_CSD_CID_BYTES);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDQuerySDMMCInfo: failed to get CID. \n"));
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ pDevice->pId[0].SDMMC_ManfacturerID = GET_SD_CID_MANFID(CID);
|
|
|
|
|
|
+ pDevice->pId[0].SDMMC_OEMApplicationID = GET_SD_CID_OEMID(CID);
|
|
|
|
|
|
+#if DEBUG
|
|
|
|
|
|
+ {
|
|
|
|
|
|
+ char pBuf[7];
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pBuf[0] = GET_SD_CID_PN_1(CID);
|
|
|
|
|
|
+ pBuf[1] = GET_SD_CID_PN_2(CID);
|
|
|
|
|
|
+ pBuf[2] = GET_SD_CID_PN_3(CID);
|
|
|
|
|
|
+ pBuf[3] = GET_SD_CID_PN_4(CID);
|
|
|
|
|
|
+ pBuf[4] = GET_SD_CID_PN_5(CID);
|
|
|
|
|
|
+ if (pDevice->pHcd->CardProperties.Flags & CARD_MMC) {
|
|
|
|
|
|
+ pBuf[5] = GET_SD_CID_PN_6(CID);
|
|
|
|
|
|
+ pBuf[6] = 0;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ pBuf[5] = 0;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDQuerySDMMCInfo: Product String: %s\n", pBuf));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDQuerySDMMCInfo: ManfID: 0x%X, OEMID:0x%X \n",
|
|
|
|
|
|
+ pDevice->pId[0].SDMMC_ManfacturerID, pDevice->pId[0].SDMMC_OEMApplicationID));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* re-select card */
|
|
|
|
|
|
+ status = SelectDeselectCard(pDevice->pHcd,TRUE);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to re-select card after getting CID \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pReq != NULL) {
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ SDQuerySDIOInfo - query SDIO card info
|
|
|
|
|
|
+ Input: pDevice - the device
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS SDQuerySDIOInfo(PSDDEVICE pDevice)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ UINT32 faddress;
|
|
|
|
|
|
+ UINT8 fInfo;
|
|
|
|
|
|
+ UINT32 nextTpl;
|
|
|
|
|
|
+ UINT8 tplLength;
|
|
|
|
|
|
+ UINT8 cisPtrBuffer[3];
|
|
|
|
|
|
+ struct SDIO_FUNC_EXT_FUNCTION_TPL_1_1 funcTuple;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* use the card-wide SDIO manufacturer code and ID previously read.*/
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_ManufacturerCode = pDevice->pHcd->CardProperties.SDIO_ManufacturerCode;
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_ManufacturerID = pDevice->pHcd->CardProperties.SDIO_ManufacturerID;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* calculate function base address */
|
|
|
|
|
|
+ faddress = CalculateFBROffset(SDDEVICE_GET_SDIO_FUNCNO(pDevice));
|
|
|
|
|
|
+ DBG_ASSERT(faddress != 0);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ status = Cmd52ReadByteCommon(pDevice,
|
|
|
|
|
|
+ FBR_FUNC_INFO_REG_OFFSET(faddress),
|
|
|
|
|
|
+ &fInfo);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to get function info, Err:%d , using Class:UNKNOWN\n", status));
|
|
|
|
|
|
+ fInfo = 0;
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_FunctionClass = 0;
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_FunctionClass = fInfo & FUNC_INFO_DEVICE_CODE_MASK;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if ((FUNC_INFO_DEVICE_CODE_LAST == pDevice->pId[0].SDIO_FunctionClass) &&
|
|
|
|
|
|
+ SDDEVICE_IS_SDIO_REV_GTEQ_1_10(pDevice)) {
|
|
|
|
|
|
+ /* if the device code is the last one, check for 1.1 revision and get the
|
|
|
|
|
|
+ * extended code */
|
|
|
|
|
|
+ status = Cmd52ReadByteCommon(pDevice,
|
|
|
|
|
|
+ FBR_FUNC_EXT_DEVICE_CODE_OFFSET(faddress),
|
|
|
|
|
|
+ &(pDevice->pId[0].SDIO_FunctionClass));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to get 1.1 extended DC, Err:%d\n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* get the function CIS ptr */
|
|
|
|
|
|
+ status = Cmd52ReadMultipleCommon(pDevice,
|
|
|
|
|
|
+ FBR_FUNC_CIS_LOW_OFFSET(faddress),
|
|
|
|
|
|
+ cisPtrBuffer,
|
|
|
|
|
|
+ 3);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to get FN CIS ptr, Err:%d\n", status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* endian safe */
|
|
|
|
|
|
+ pDevice->DeviceInfo.AsSDIOInfo.FunctionCISPtr = ((UINT32)cisPtrBuffer[0]) |
|
|
|
|
|
|
+ (((UINT32)cisPtrBuffer[1]) << 8) |
|
|
|
|
|
|
+ (((UINT32)cisPtrBuffer[2]) << 16);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Function:%d, Class:%d FnCISPtr:0x%X \n",
|
|
|
|
|
|
+ SDDEVICE_GET_SDIO_FUNCNO(pDevice),
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_FunctionClass,pDevice->DeviceInfo.AsSDIOInfo.FunctionCISPtr));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (fInfo & FUNC_INFO_SUPPORTS_CSA_MASK) {
|
|
|
|
|
|
+ /* get the function CSA ptr */
|
|
|
|
|
|
+ status = Cmd52ReadMultipleCommon(pDevice,
|
|
|
|
|
|
+ FBR_FUNC_CSA_LOW_OFFSET(faddress),
|
|
|
|
|
|
+ cisPtrBuffer,
|
|
|
|
|
|
+ 3);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to get FN CSA ptr, Err:%d \n", status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* endian safe */
|
|
|
|
|
|
+ pDevice->DeviceInfo.AsSDIOInfo.FunctionCSAPtr = ((UINT32)cisPtrBuffer[0]) |
|
|
|
|
|
|
+ (((UINT32)cisPtrBuffer[1]) << 8) |
|
|
|
|
|
|
+ (((UINT32)cisPtrBuffer[2]) << 16);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ nextTpl = SDDEVICE_GET_SDIO_FUNC_CISPTR(pDevice);
|
|
|
|
|
|
+ /* look for the funce TPL */
|
|
|
|
|
|
+ tplLength = sizeof(funcTuple);
|
|
|
|
|
|
+ /* go get the func CE tuple */
|
|
|
|
|
|
+ status = SDLIB_FindTuple(pDevice,
|
|
|
|
|
|
+ CISTPL_FUNCE,
|
|
|
|
|
|
+ &nextTpl,
|
|
|
|
|
|
+ (PUINT8)&funcTuple,
|
|
|
|
|
|
+ &tplLength);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)){
|
|
|
|
|
|
+ /* handles case of bad CIS or missing tupple, allow function driver to handle */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: Failed to get FuncCE Tuple: %d \n", status));
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* set the max block size */
|
|
|
|
|
|
+ pDevice->DeviceInfo.AsSDIOInfo.FunctionMaxBlockSize =
|
|
|
|
|
|
+ CT_LE16_TO_CPU_ENDIAN(funcTuple.CommonInfo.MaxBlockSize);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Function:%d, MaxBlocks:%d \n",
|
|
|
|
|
|
+ SDDEVICE_GET_SDIO_FUNCNO(pDevice),
|
|
|
|
|
|
+ pDevice->DeviceInfo.AsSDIOInfo.FunctionMaxBlockSize));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check for MANFID function tuple (SDIO 1.1 or greater) */
|
|
|
|
|
|
+ if (SDDEVICE_IS_SDIO_REV_GTEQ_1_10(pDevice)) {
|
|
|
|
|
|
+ struct SDIO_MANFID_TPL manfid;
|
|
|
|
|
|
+ nextTpl = SDDEVICE_GET_SDIO_FUNC_CISPTR(pDevice);
|
|
|
|
|
|
+ tplLength = sizeof(manfid);
|
|
|
|
|
|
+ /* get the MANFID tuple */
|
|
|
|
|
|
+ status = SDLIB_FindTuple(pDevice,
|
|
|
|
|
|
+ CISTPL_MANFID,
|
|
|
|
|
|
+ &nextTpl,
|
|
|
|
|
|
+ (PUINT8)&manfid,
|
|
|
|
|
|
+ &tplLength);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* this function has a MANFID tuple */
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_ManufacturerCode =
|
|
|
|
|
|
+ CT_LE16_TO_CPU_ENDIAN(manfid.ManufacturerCode);
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_ManufacturerID =
|
|
|
|
|
|
+ CT_LE16_TO_CPU_ENDIAN(manfid.ManufacturerInfo);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO 1.1 (Function Specific) MANFID:0x%X, MANFINFO:0x%X \n",
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_ManufacturerID,
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_ManufacturerCode));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO 1.1, No CISTPL_MANFID Tuple in FUNC CIS \n"));
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ SDEnableFunction - enable function
|
|
|
|
|
|
+ Input: pDevice - the device/function
|
|
|
|
|
|
+ pEnData - enable data;
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return: status
|
|
|
|
|
|
+ Notes: Note, this performs synchronous calls
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS SDEnableFunction(PSDDEVICE pDevice, PSDCONFIG_FUNC_ENABLE_DISABLE_DATA pEnData)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ UINT8 registerValue;
|
|
|
|
|
|
+ UINT8 mask;
|
|
|
|
|
|
+ FUNC_ENABLE_TIMEOUT retry;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* take the configure op lock to make this atomic */
|
|
|
|
|
|
+ status = SemaphorePendInterruptable(&pDevice->pHcd->ConfigureOpsSem);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ if (!(pDevice->pHcd->CardProperties.Flags & CARD_SDIO)){
|
|
|
|
|
|
+ /* nothing to do if it's not an SDIO card */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!((SDDEVICE_GET_SDIO_FUNCNO(pDevice) >= SDIO_FIRST_FUNCTION_NUMBER) &&
|
|
|
|
|
|
+ (SDDEVICE_GET_SDIO_FUNCNO(pDevice) <= SDIO_LAST_FUNCTION_NUMBER))){
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* make sure there is a timeout value */
|
|
|
|
|
|
+ if (0 == pEnData->TimeOut) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ mask = 1 << SDDEVICE_GET_SDIO_FUNCNO(pDevice);
|
|
|
|
|
|
+ /* read the enable register */
|
|
|
|
|
|
+ status = Cmd52ReadByteCommon(pDevice, SDIO_ENABLE_REG, ®isterValue);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)){
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (pEnData->EnableFlags & SDCONFIG_ENABLE_FUNC) {
|
|
|
|
|
|
+ /* set the enable register bit */
|
|
|
|
|
|
+ registerValue |= mask;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* clear the bit */
|
|
|
|
|
|
+ registerValue &= ~mask;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO Bus Driver %s Function, Mask:0x%X Enable Reg Value:0x%2.2X\n",
|
|
|
|
|
|
+ (pEnData->EnableFlags & SDCONFIG_ENABLE_FUNC) ? "Enabling":"Disabling",
|
|
|
|
|
|
+ mask,
|
|
|
|
|
|
+ registerValue));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* write it back out */
|
|
|
|
|
|
+ status = Cmd52WriteByteCommon(pDevice, SDIO_ENABLE_REG, ®isterValue);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)){
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* now poll the ready bit until it sets or clears */
|
|
|
|
|
|
+ retry = pEnData->TimeOut;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Function Enable/Disable Polling: %d retries \n",
|
|
|
|
|
|
+ retry));
|
|
|
|
|
|
+ while (retry) {
|
|
|
|
|
|
+ status = Cmd52ReadByteCommon(pDevice, SDIO_READY_REG, ®isterValue);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)){
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (pEnData->EnableFlags & SDCONFIG_ENABLE_FUNC) {
|
|
|
|
|
|
+ /* if the bit is set, the device is ready */
|
|
|
|
|
|
+ if (registerValue & mask) {
|
|
|
|
|
|
+ /* device ready */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ if (!(registerValue & mask)) {
|
|
|
|
|
|
+ /* device is no longer ready */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* sleep before trying again */
|
|
|
|
|
|
+ status = OSSleep(1);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("OSSleep Failed! \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ retry--;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (0 == retry) {
|
|
|
|
|
|
+ status = SDIO_STATUS_FUNC_ENABLE_TIMEOUT;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ SemaphorePost(&pDevice->pHcd->ConfigureOpsSem);
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ SDAllocFreeSlotCurrent - allocate or free slot current
|
|
|
|
|
|
+ Input: pDevice - the device/function
|
|
|
|
|
|
+ Allocate - Allocate current, else free
|
|
|
|
|
|
+ pData - slotcurrent data (non-NULL if Allocate is TRUE)
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return: status
|
|
|
|
|
|
+ Notes: if the function returns SDIO_STATUS_NO_RESOURCES, the pData->SlotCurrent field is
|
|
|
|
|
|
+ updated with the available current
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS SDAllocFreeSlotCurrent(PSDDEVICE pDevice, BOOL Allocate, PSDCONFIG_FUNC_SLOT_CURRENT_DATA pData)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: SDAllocFreeSlotCurrent\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* take the configure op lock to make this atomic */
|
|
|
|
|
|
+ status = SemaphorePendInterruptable(&pDevice->pHcd->ConfigureOpsSem);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ /* check the current budget and allocate */
|
|
|
|
|
|
+ if (Allocate) {
|
|
|
|
|
|
+ if (0 == pData->SlotCurrent) {
|
|
|
|
|
|
+ /* caller must specify current requirement for the power mode */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (pDevice->SlotCurrentAlloc != 0) {
|
|
|
|
|
|
+ /* slot current has already been allocated, caller needs to free
|
|
|
|
|
|
+ * first */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Slot Current Already allocated! \n"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (((UINT32)pDevice->pHcd->SlotCurrentAllocated + (UINT32)pData->SlotCurrent) >
|
|
|
|
|
|
+ (UINT32)pDevice->pHcd->MaxSlotCurrent) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Slot Current Budget exceeded, Requesting: %d, Allocated already: %d, Max: %d \n",
|
|
|
|
|
|
+ pData->SlotCurrent, pDevice->pHcd->SlotCurrentAllocated,
|
|
|
|
|
|
+ pDevice->pHcd->MaxSlotCurrent));
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ /* return remaining */
|
|
|
|
|
|
+ pData->SlotCurrent = pDevice->pHcd->MaxSlotCurrent -
|
|
|
|
|
|
+ pDevice->pHcd->SlotCurrentAllocated;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* bump up allocation */
|
|
|
|
|
|
+ pDevice->pHcd->SlotCurrentAllocated += pData->SlotCurrent;
|
|
|
|
|
|
+ /* save this off for the call to free slot current */
|
|
|
|
|
|
+ pDevice->SlotCurrentAlloc = pData->SlotCurrent;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Slot Current Requested: %d, New Total: %d, Max: %d \n",
|
|
|
|
|
|
+ pData->SlotCurrent, pDevice->pHcd->SlotCurrentAllocated,
|
|
|
|
|
|
+ pDevice->pHcd->MaxSlotCurrent));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ if (0 == pDevice->SlotCurrentAlloc) {
|
|
|
|
|
|
+ /* no allocation */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* return the allocation back */
|
|
|
|
|
|
+ if (pDevice->SlotCurrentAlloc <= pDevice->pHcd->SlotCurrentAllocated) {
|
|
|
|
|
|
+ pDevice->pHcd->SlotCurrentAllocated -= pDevice->SlotCurrentAlloc;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Slot Current Freed: %d, New Total: %d, Max: %d \n",
|
|
|
|
|
|
+ pDevice->SlotCurrentAlloc, pDevice->pHcd->SlotCurrentAllocated,
|
|
|
|
|
|
+ pDevice->pHcd->MaxSlotCurrent));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* make sure this is zeroed */
|
|
|
|
|
|
+ pDevice->SlotCurrentAlloc = 0;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ SemaphorePost(&pDevice->pHcd->ConfigureOpsSem);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("-SDIO Bus Driver: SDAllocFreeSlotCurrent, %d\n", status));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static void RawHcdIrqControl(PSDHCD pHcd, BOOL Enable)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ SDCONFIG_SDIO_INT_CTRL_DATA irqData;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ ZERO_OBJECT(irqData);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _AcquireHcdLock(pHcd);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ /* for raw devices, we simply enable/disable in the HCD only */
|
|
|
|
|
|
+ if (Enable) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver (RAW) Unmasking Int \n"));
|
|
|
|
|
|
+ irqData.IRQDetectMode = IRQ_DETECT_RAW;
|
|
|
|
|
|
+ irqData.SlotIRQEnable = TRUE;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver (RAW) Masking Int \n"));
|
|
|
|
|
|
+ irqData.SlotIRQEnable = FALSE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _IssueConfig(pHcd,SDCONFIG_SDIO_INT_CTRL,
|
|
|
|
|
|
+ (PVOID)&irqData, sizeof(irqData));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)){
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver failed to enable/disable IRQ in (RAW) hcd :%d\n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static void RawHcdEnableIrqPseudoComplete(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ if (SDIO_SUCCESS(pReq->Status)) {
|
|
|
|
|
|
+ RawHcdIrqControl((PSDHCD)pReq->pCompleteContext, TRUE);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static void RawHcdDisableIrqPseudoComplete(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ RawHcdIrqControl((PSDHCD)pReq->pCompleteContext, FALSE);
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static void HcdIrqControl(PSDHCD pHcd, BOOL Enable)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ SDCONFIG_SDIO_INT_CTRL_DATA irqData;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ ZERO_OBJECT(irqData);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _AcquireHcdLock(pHcd);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: HcdIrqControl (%s), IrqsEnabled:0x%X \n",
|
|
|
|
|
|
+ Enable ? "Enable":"Disable",pHcd->IrqsEnabled ));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (Enable) {
|
|
|
|
|
|
+ irqData.SlotIRQEnable = TRUE;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ irqData.SlotIRQEnable = FALSE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* setup HCD to enable/disable it's detection hardware */
|
|
|
|
|
|
+ if (irqData.SlotIRQEnable) {
|
|
|
|
|
|
+ /* set the IRQ detection mode */
|
|
|
|
|
|
+ switch (SDCONFIG_GET_BUSWIDTH(pHcd->CardProperties.BusMode)) {
|
|
|
|
|
|
+ case SDCONFIG_BUS_WIDTH_SPI:
|
|
|
|
|
|
+ irqData.IRQDetectMode = IRQ_DETECT_SPI;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_BUS_WIDTH_1_BIT:
|
|
|
|
|
|
+ irqData.IRQDetectMode = IRQ_DETECT_1_BIT;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDCONFIG_BUS_WIDTH_4_BIT:
|
|
|
|
|
|
+ irqData.IRQDetectMode = IRQ_DETECT_4_BIT;
|
|
|
|
|
|
+ /* check card and HCD for 4bit multi-block interrupt support */
|
|
|
|
|
|
+ if ((pHcd->CardProperties.SDIOCaps & SDIO_CAPS_INT_MULTI_BLK) &&
|
|
|
|
|
|
+ (pHcd->Attributes & SDHCD_ATTRIB_MULTI_BLK_IRQ)) {
|
|
|
|
|
|
+ /* note: during initialization of the card, the mult-blk IRQ support
|
|
|
|
|
|
+ * is enabled in card caps register */
|
|
|
|
|
|
+ irqData.IRQDetectMode |= IRQ_DETECT_MULTI_BLK;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver enabling IRQ in multi-block mode:\n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver enabling IRQ in HCD Mode:0x%X\n",
|
|
|
|
|
|
+ irqData.IRQDetectMode));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _IssueConfig(pHcd,SDCONFIG_SDIO_INT_CTRL,
|
|
|
|
|
|
+ (PVOID)&irqData, sizeof(irqData));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)){
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver failed to enable/disable IRQ in hcd %d\n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pHcd);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static BOOL CheckWriteIntEnableSuccess(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(pReq->Status)){
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to get write INT Enable register Err:%d\n",
|
|
|
|
|
|
+ pReq->Status));
|
|
|
|
|
|
+ return FALSE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SD_R5_GET_RESP_FLAGS(pReq->Response) & SD_R5_ERRORS) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: WriteIntEnableComplete CMD52 resp error: 0x%X \n",
|
|
|
|
|
|
+ SD_R5_GET_RESP_FLAGS(pReq->Response)));
|
|
|
|
|
|
+ return FALSE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return TRUE;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static void HcdIrqEnableComplete(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ if (CheckWriteIntEnableSuccess(pReq)) {
|
|
|
|
|
|
+ /* configure HCD */
|
|
|
|
|
|
+ HcdIrqControl((PSDHCD)pReq->pCompleteContext, TRUE);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static void HcdIrqDisableComplete(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ CheckWriteIntEnableSuccess(pReq);
|
|
|
|
|
|
+ HcdIrqControl((PSDHCD)pReq->pCompleteContext, FALSE);
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static void WriteIntEnableComplete(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ if (CheckWriteIntEnableSuccess(pReq)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: Wrote INT Enable value:0x%X \n",
|
|
|
|
|
|
+ (INT)pReq->pCompleteContext));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static void HcdAckComplete(PSDREQUEST pReq)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_FUNC_IRQ, ("SDIO Bus Driver: Hcd (0x%X) Irq Ack \n",
|
|
|
|
|
|
+ (INT)pReq->pCompleteContext));
|
|
|
|
|
|
+ /* re-arm the HCD */
|
|
|
|
|
|
+ status = _IssueConfig((PSDHCD)pReq->pCompleteContext,SDCONFIG_SDIO_REARM_INT,NULL,0);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: HCD Re-Arm failed : %d\n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ SDFunctionAckInterrupt - handle device interrupt acknowledgement
|
|
|
|
|
|
+ Input: pDevice - the device
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS SDFunctionAckInterrupt(PSDDEVICE pDevice)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ UCHAR mask;
|
|
|
|
|
|
+ PSDREQUEST pReq = NULL;
|
|
|
|
|
|
+ BOOL setHcd = FALSE;
|
|
|
|
|
|
+ SDIO_STATUS status2;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pReq = AllocateRequest();
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ return SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _AcquireHcdLock(pDevice->pHcd);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ if (!((SDDEVICE_GET_SDIO_FUNCNO(pDevice) >= SDIO_FIRST_FUNCTION_NUMBER) &&
|
|
|
|
|
|
+ (SDDEVICE_GET_SDIO_FUNCNO(pDevice) <= SDIO_LAST_FUNCTION_NUMBER))){
|
|
|
|
|
|
+ status = SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ mask = 1 << SDDEVICE_GET_SDIO_FUNCNO(pDevice);
|
|
|
|
|
|
+ if (pDevice->pHcd->PendingIrqAcks & mask) {
|
|
|
|
|
|
+ /* clear the ack bit in question */
|
|
|
|
|
|
+ pDevice->pHcd->PendingIrqAcks &= ~mask;
|
|
|
|
|
|
+ if (0 == pDevice->pHcd->PendingIrqAcks) {
|
|
|
|
|
|
+ pDevice->pHcd->IrqProcState = SDHCD_IDLE;
|
|
|
|
|
|
+ /* no pending acks, so re-arm if irqs are stilled enabled */
|
|
|
|
|
|
+ if (pDevice->pHcd->IrqsEnabled) {
|
|
|
|
|
|
+ setHcd = TRUE;
|
|
|
|
|
|
+ /* issue pseudo request to sync this with bus requests */
|
|
|
|
|
|
+ pReq->Status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ pReq->pCompletion = HcdAckComplete;
|
|
|
|
|
|
+ pReq->pCompleteContext = pDevice->pHcd;
|
|
|
|
|
|
+ pReq->Flags = SD_PSEUDO_REQ_FLAGS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: AckInterrupt: no IRQ pending on Function :%d, \n",
|
|
|
|
|
|
+ SDDEVICE_GET_SDIO_FUNCNO(pDevice)));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status2 = ReleaseHcdLock(pDevice);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pReq != NULL) {
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status) && (setHcd)) {
|
|
|
|
|
|
+ /* issue request */
|
|
|
|
|
|
+ IssueRequestToHCD(pDevice->pHcd,pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ SDMaskUnmaskFunctionIRQ - mask/unmask function IRQ
|
|
|
|
|
|
+ Input: pDevice - the device/function
|
|
|
|
|
|
+ MaskInt - mask interrupt
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return: status
|
|
|
|
|
|
+ Notes: Note, this function can be called from an ISR or completion context
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS SDMaskUnmaskFunctionIRQ(PSDDEVICE pDevice, BOOL MaskInt)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ UINT8 mask;
|
|
|
|
|
|
+ UINT8 controlVal;
|
|
|
|
|
|
+ BOOL setHcd;
|
|
|
|
|
|
+ PSDREQUEST pReq = NULL;
|
|
|
|
|
|
+ SDIO_STATUS status2;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ setHcd = FALSE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pReq = AllocateRequest();
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ return SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _AcquireHcdLock(pDevice->pHcd);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pDevice->pHcd->CardProperties.Flags & CARD_RAW) {
|
|
|
|
|
|
+ if (!MaskInt) {
|
|
|
|
|
|
+ if (!pDevice->pHcd->IrqsEnabled) {
|
|
|
|
|
|
+ pReq->pCompletion = RawHcdEnableIrqPseudoComplete;
|
|
|
|
|
|
+ setHcd = TRUE;
|
|
|
|
|
|
+ pDevice->pHcd->IrqsEnabled = 1 << 1;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ if (pDevice->pHcd->IrqsEnabled) {
|
|
|
|
|
|
+ pReq->pCompletion = RawHcdDisableIrqPseudoComplete;
|
|
|
|
|
|
+ setHcd = TRUE;
|
|
|
|
|
|
+ pDevice->pHcd->IrqsEnabled = 0;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (setHcd) {
|
|
|
|
|
|
+ /* hcd IRQ control requests must be synched with outstanding
|
|
|
|
|
|
+ * bus requests so we issue a pseudo bus request */
|
|
|
|
|
|
+ pReq->pCompleteContext = pDevice->pHcd;
|
|
|
|
|
|
+ pReq->Flags = SD_PSEUDO_REQ_FLAGS;
|
|
|
|
|
|
+ pReq->Status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* no request to submit, just free it */
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+ pReq = NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* we're done, submit the bus request if any */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!(pDevice->pHcd->CardProperties.Flags & CARD_SDIO)){
|
|
|
|
|
|
+ /* nothing to do if it's not an SDIO card */
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ status = SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!((SDDEVICE_GET_SDIO_FUNCNO(pDevice) >= SDIO_FIRST_FUNCTION_NUMBER) &&
|
|
|
|
|
|
+ (SDDEVICE_GET_SDIO_FUNCNO(pDevice) <= SDIO_LAST_FUNCTION_NUMBER))){
|
|
|
|
|
|
+ status = SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ mask = 1 << SDDEVICE_GET_SDIO_FUNCNO(pDevice);
|
|
|
|
|
|
+ if (!MaskInt) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver Unmasking Int, Mask:0x%X\n", mask));
|
|
|
|
|
|
+ /* check interrupts that were enabled on entry */
|
|
|
|
|
|
+ if (0 == pDevice->pHcd->IrqsEnabled) {
|
|
|
|
|
|
+ /* need to turn on interrupts in HCD */
|
|
|
|
|
|
+ setHcd = TRUE;
|
|
|
|
|
|
+ /* use this completion routine */
|
|
|
|
|
|
+ pReq->pCompletion = HcdIrqEnableComplete;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* set the enable bit, in the shadow register */
|
|
|
|
|
|
+ pDevice->pHcd->IrqsEnabled |= mask;
|
|
|
|
|
|
+ /* make sure control value includes the master enable */
|
|
|
|
|
|
+ controlVal = pDevice->pHcd->IrqsEnabled | SDIO_INT_MASTER_ENABLE;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver Masking Int, Mask:0x%X\n", mask));
|
|
|
|
|
|
+ /* clear the bit */
|
|
|
|
|
|
+ pDevice->pHcd->IrqsEnabled &= ~mask;
|
|
|
|
|
|
+ /* check and see if this clears all the bits */
|
|
|
|
|
|
+ if (0 == pDevice->pHcd->IrqsEnabled){
|
|
|
|
|
|
+ /* if none of the functions are enabled, clear this register */
|
|
|
|
|
|
+ controlVal = 0;
|
|
|
|
|
|
+ /* disable in host */
|
|
|
|
|
|
+ setHcd = TRUE;
|
|
|
|
|
|
+ /* use this completion routine */
|
|
|
|
|
|
+ pReq->pCompletion = HcdIrqDisableComplete;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* set control value making sure master enable is left on */
|
|
|
|
|
|
+ controlVal = pDevice->pHcd->IrqsEnabled | SDIO_INT_MASTER_ENABLE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver INT_ENABLE_REG value:0x%X\n", controlVal));
|
|
|
|
|
|
+ /* setup bus request to update the mask register */
|
|
|
|
|
|
+ SDIO_SET_CMD52_WRITE_ARG(pReq->Argument,0,SDIO_INT_ENABLE_REG,controlVal);
|
|
|
|
|
|
+ pReq->Command = CMD52;
|
|
|
|
|
|
+ pReq->Flags = SDREQ_FLAGS_TRANS_ASYNC | SDREQ_FLAGS_RESP_SDIO_R5;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (setHcd) {
|
|
|
|
|
|
+ /* make this a barrier request and set context*/
|
|
|
|
|
|
+ pReq->Flags |= SDREQ_FLAGS_BARRIER;
|
|
|
|
|
|
+ pReq->pCompleteContext = pDevice->pHcd;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* does not require an update to the HCD */
|
|
|
|
|
|
+ pReq->pCompleteContext = (PVOID)(UINT32)controlVal;
|
|
|
|
|
|
+ pReq->pCompletion = WriteIntEnableComplete;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status2 = _ReleaseHcdLock(pDevice->pHcd);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pReq != NULL) {
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* issue request */
|
|
|
|
|
|
+ IssueRequestToHCD(pDevice->pHcd,pReq);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ FreeRequest(pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ SDSPIModeEnableDisableCRC - Enable/Disable SPI Mode CRC checking
|
|
|
|
|
|
+ Input: pDevice - the device/function
|
|
|
|
|
|
+ Enable - Enable CRC
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return: status
|
|
|
|
|
|
+ Notes: Note, this function can be called from an ISR or completion context
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS SDSPIModeEnableDisableCRC(PSDDEVICE pDevice,BOOL Enable)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDCONFIG_BUS_MODE_DATA busMode;
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ UINT32 cmdARG = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDDEVICE_IS_BUSMODE_SPI(pDevice)) {
|
|
|
|
|
|
+ return SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ //??we should make these atomic using a barrier
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* get the current mode and clock */
|
|
|
|
|
|
+ busMode.BusModeFlags = pDevice->pHcd->CardProperties.BusMode;
|
|
|
|
|
|
+ busMode.ClockRate = pDevice->pHcd->CardProperties.OperBusClock;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (Enable) {
|
|
|
|
|
|
+ /* clear the no-CRC flag */
|
|
|
|
|
|
+ busMode.BusModeFlags &= ~SDCONFIG_BUS_MODE_SPI_NO_CRC;
|
|
|
|
|
|
+ cmdARG = SD_CMD59_CRC_ON;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ busMode.BusModeFlags |= SDCONFIG_BUS_MODE_SPI_NO_CRC;
|
|
|
|
|
|
+ cmdARG = SD_CMD59_CRC_OFF;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ /* issue CMD59 to turn on/off CRC */
|
|
|
|
|
|
+ status = _IssueSimpleBusRequest(pDevice->pHcd,
|
|
|
|
|
|
+ CMD59,
|
|
|
|
|
|
+ cmdARG,
|
|
|
|
|
|
+ SDREQ_FLAGS_RESP_R1,
|
|
|
|
|
|
+ NULL);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed issue CMD59 (arg=0x%X) Err:%d \n",
|
|
|
|
|
|
+ cmdARG, status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (Enable) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: CRC Enabled in SPI mode \n"));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: CRC Disabled in SPI mode \n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ status = SetOperationalBusMode(pDevice,&busMode);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Failed to set SPI NO CRC mode in hcd : Err:%d \n",
|
|
|
|
|
|
+ status));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+static UINT32 ConvertSPIStatusToSDCardStatus(UINT8 SpiR1, UINT8 SpiR2)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ UINT32 cardStatus = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SpiR1 != 0) {
|
|
|
|
|
|
+ /* convert the error */
|
|
|
|
|
|
+ if (SpiR1 & SPI_CS_ERASE_RESET) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_ERASE_RESET;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SpiR1 & SPI_CS_ILLEGAL_CMD) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_ILLEGAL_CMD_ERR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SpiR1 & SPI_CS_CMD_CRC_ERR) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_PREV_CMD_CRC_ERR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SpiR1 & SPI_CS_ERASE_SEQ_ERR) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_ERASE_SEQ_ERR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SpiR1 & SPI_CS_ADDRESS_ERR) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_ADDRESS_ERR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SpiR1 & SPI_CS_PARAM_ERR) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_CMD_OUT_OF_RANGE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (SpiR2 != 0) {
|
|
|
|
|
|
+ /* convert the error */
|
|
|
|
|
|
+ if (SpiR2 & SPI_CS_CARD_IS_LOCKED) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_CARD_LOCKED;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SpiR2 & SPI_CS_LOCK_UNLOCK_FAILED) {
|
|
|
|
|
|
+ /* this bit is shared, just set both */
|
|
|
|
|
|
+ cardStatus |= (SD_CS_LK_UNLK_FAILED | SD_CS_WP_ERASE_SKIP);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SpiR2 & SPI_CS_ERROR) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_GENERAL_ERR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SpiR2 & SPI_CS_INTERNAL_ERROR) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_CARD_INTERNAL_ERR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SpiR2 & SPI_CS_ECC_FAILED) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_ECC_FAILED;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SpiR2 & SPI_CS_WP_VIOLATION) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_WP_ERR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SpiR2 & SPI_CS_ERASE_PARAM_ERR) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_ERASE_PARAM_ERR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SpiR2 & SPI_CS_OUT_OF_RANGE) {
|
|
|
|
|
|
+ cardStatus |= SD_CS_CMD_OUT_OF_RANGE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return cardStatus;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ ConvertSPI_Response - filter the SPI response and convert it to an SD Response
|
|
|
|
|
|
+ Input: pReq - request
|
|
|
|
|
|
+ Output: pReq - modified response, if pRespBuffer is not NULL
|
|
|
|
|
|
+ pRespBuffer - converted response (optional)
|
|
|
|
|
|
+ Return:
|
|
|
|
|
|
+ Notes: This function converts a SPI response into an SD response. A caller
|
|
|
|
|
|
+ can supply a buffer instead.
|
|
|
|
|
|
+ For SPI bus operation the HCD must send the SPI response as
|
|
|
|
|
|
+ a stream of bytes, the highest byte contains the first received byte from the
|
|
|
|
|
|
+ card. This function only filters simple responses (R1 primarily).
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+void ConvertSPI_Response(PSDREQUEST pReq, UINT8 *pRespBuffer)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+
|
|
|
|
|
|
+ UINT32 cardStatus;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pReq->Flags & SDREQ_FLAGS_RESP_SPI_CONVERTED) {
|
|
|
|
|
|
+ /* already converted */
|
|
|
|
|
|
+ return;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (NULL == pRespBuffer) {
|
|
|
|
|
|
+ pRespBuffer = pReq->Response;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ switch (GET_SDREQ_RESP_TYPE(pReq->Flags)) {
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_R1:
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_R1B:
|
|
|
|
|
|
+ cardStatus = ConvertSPIStatusToSDCardStatus(GET_SPI_R1_RESP_TOKEN(pReq->Response),
|
|
|
|
|
|
+ 0);
|
|
|
|
|
|
+ if (CMD55 == pReq->Command) {
|
|
|
|
|
|
+ /* we emulate this since SPI does not have such a bit */
|
|
|
|
|
|
+ cardStatus |= SD_CS_APP_CMD;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* stuff the SD card status */
|
|
|
|
|
|
+ SD_R1_SET_CMD_STATUS(pRespBuffer,cardStatus);
|
|
|
|
|
|
+ /* stuff the command */
|
|
|
|
|
|
+ SD_R1_SET_CMD(pRespBuffer,pReq->Command);
|
|
|
|
|
|
+ pReq->Flags |= SDREQ_FLAGS_RESP_SPI_CONVERTED;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_SDIO_R5:
|
|
|
|
|
|
+ {
|
|
|
|
|
|
+ UINT8 respFlags;
|
|
|
|
|
|
+ UINT8 readData;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ readData = GET_SPI_SDIO_R5_RESPONSE_RDATA(pReq->Response);
|
|
|
|
|
|
+ respFlags = GET_SPI_SDIO_R5_RESP_TOKEN(pReq->Response);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pRespBuffer[SD_R5_RESP_FLAGS_OFFSET] = 0;
|
|
|
|
|
|
+ if (respFlags != 0) {
|
|
|
|
|
|
+ if (respFlags & SPI_R5_ILLEGAL_CMD) {
|
|
|
|
|
|
+ pRespBuffer[SD_R5_RESP_FLAGS_OFFSET] |= SD_R5_ILLEGAL_CMD;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (respFlags & SPI_R5_CMD_CRC) {
|
|
|
|
|
|
+ pRespBuffer[SD_R5_RESP_FLAGS_OFFSET] |= SD_R5_RESP_CMD_ERR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (respFlags & SPI_R5_FUNC_ERR) {
|
|
|
|
|
|
+ pRespBuffer[SD_R5_RESP_FLAGS_OFFSET] |= SD_R5_INVALID_FUNC;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (respFlags & SPI_R5_PARAM_ERR) {
|
|
|
|
|
|
+ pRespBuffer[SD_R5_RESP_FLAGS_OFFSET] |= SD_R5_ARG_RANGE_ERR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* stuff read data */
|
|
|
|
|
|
+ pRespBuffer[SD_SDIO_R5_READ_DATA_OFFSET] = readData;
|
|
|
|
|
|
+ /* stuff the command */
|
|
|
|
|
|
+ SD_R5_SET_CMD(pRespBuffer,pReq->Command);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ pReq->Flags |= SDREQ_FLAGS_RESP_SPI_CONVERTED;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_R2:
|
|
|
|
|
|
+ /* for CMD13 and ACMD13 , SPI uses it's own R2 response format (2 bytes) */
|
|
|
|
|
|
+ /* the issue of CMD13 needs to change the response flag to R2 */
|
|
|
|
|
|
+ if (CMD13 == pReq->Command) {
|
|
|
|
|
|
+ cardStatus = ConvertSPIStatusToSDCardStatus(
|
|
|
|
|
|
+ GET_SPI_R2_RESP_TOKEN(pReq->Response),
|
|
|
|
|
|
+ GET_SPI_R2_STATUS_TOKEN(pReq->Response));
|
|
|
|
|
|
+ /* stuff the SD card status */
|
|
|
|
|
|
+ SD_R1_SET_CMD_STATUS(pRespBuffer,cardStatus);
|
|
|
|
|
|
+ /* stuff the command */
|
|
|
|
|
|
+ SD_R1_SET_CMD(pRespBuffer,pReq->Command);
|
|
|
|
|
|
+ pReq->Flags |= SDREQ_FLAGS_RESP_SPI_CONVERTED;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* no other commands should be using R2 when using SPI, if they are
|
|
|
|
|
|
+ * they should be bypassing the filter */
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ /* for all others:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * SDREQ_FLAGS_RESP_R6 - SPI mode does not use RCA
|
|
|
|
|
|
+ * SDREQ_FLAGS_RESP_R3 - bus driver handles this internally
|
|
|
|
|
|
+ * SDREQ_FLAGS_RESP_SDIO_R4 - bus driver handles this internally
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("ConvertSPI_Response - invalid response type:0x%2.2X",
|
|
|
|
|
|
+ GET_SDREQ_RESP_TYPE(pReq->Flags)));
|
|
|
|
|
|
+ DBG_ASSERT(FALSE);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Check an SD/MMC/SDIO response.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDIO_CheckResponse
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDIO_CheckResponse(PSDHCD pHcd, PSDREQUEST pReq, SDHCD_RESPONSE_CHECK_MODE CheckMode)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pHcd - the host controller definition structure.
|
|
|
|
|
|
+ @input: pReq - request containing the response
|
|
|
|
|
|
+ @input: CheckMode - mode
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Host controller drivers must call into this function to validate various command
|
|
|
|
|
|
+ responses before continuing with data transfers or for decoding received SPI tokens.
|
|
|
|
|
|
+ The CheckMode option determines the type of validation to perform.
|
|
|
|
|
|
+ if (CheckMode == SDHCD_CHECK_DATA_TRANS_OK) :
|
|
|
|
|
|
+ The host controller must check the card response to determine whether it
|
|
|
|
|
|
+ is safe to perform a data transfer. This API only checks commands that
|
|
|
|
|
|
+ involve data transfers and checks various status fields in the command response.
|
|
|
|
|
|
+ If the card cannot accept data, this function will return a non-successful status that
|
|
|
|
|
|
+ should be treated as a request failure. The host driver should complete the request with the
|
|
|
|
|
|
+ returned status. Host controller should only call this function in preparation for a
|
|
|
|
|
|
+ data transfer.
|
|
|
|
|
|
+ if (CheckMode == SDHCD_CHECK_SPI_TOKEN) :
|
|
|
|
|
|
+ This API checks the SPI token and returns a timeout status if the illegal command bit is
|
|
|
|
|
|
+ set. This simulates the behavior of SD 1/4 bit operation where illegal commands result in
|
|
|
|
|
|
+ a command timeout. A driver that supports SPI mode should pass every response to this
|
|
|
|
|
|
+ function to determine the appropriate error status to complete the request with. If the
|
|
|
|
|
|
+ API returns success, the response indicates that the card accepted the command.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Checking the response before starting the data transfer :
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status) && (pReq->Flags & SDREQ_FLAGS_DATA_TRANS)) {
|
|
|
|
|
|
+ // check the response to see if we should continue with data
|
|
|
|
|
|
+ status = SDIO_CheckResponse(pHcd, pReq, SDHCD_CHECK_DATA_TRANS_OK);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ .... start data transfer phase
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ ... card response indicates that the card cannot handle data
|
|
|
|
|
|
+ // set completion status
|
|
|
|
|
|
+ pRequest->Status = status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ _SDIO_CheckResponse - check response on behalf of the host controller
|
|
|
|
|
|
+ Input: pHcd - host controller
|
|
|
|
|
|
+ pReq - request containing the response
|
|
|
|
|
|
+ CheckMode - mode
|
|
|
|
|
|
+ Output:
|
|
|
|
|
|
+ Return: status
|
|
|
|
|
|
+ Notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+ CheckMode == SDHCD_CHECK_DATA_TRANS_OK :
|
|
|
|
|
|
+ The host controller requests a check on the response to determine whether it
|
|
|
|
|
|
+ is okay to perform a data transfer. This function only filters on commands that
|
|
|
|
|
|
+ involve data. Host controller should only call this function in preparation for a
|
|
|
|
|
|
+ data transfer.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ CheckMode == SDHCD_CHECK_SPI_TOKEN :
|
|
|
|
|
|
+ The bus driver checks the SPI token and returns a timeout status if the illegal command bit is
|
|
|
|
|
|
+ set. This simulates the behavior of SD native operation.
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _SDIO_CheckResponse(PSDHCD pHcd, PSDREQUEST pReq, SDHCD_RESPONSE_CHECK_MODE CheckMode)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (CheckMode == SDHCD_CHECK_DATA_TRANS_OK) {
|
|
|
|
|
|
+ UINT32 cardStatus;
|
|
|
|
|
|
+ UINT8 *pResponse;
|
|
|
|
|
|
+ UINT8 convertedResponse[MAX_CARD_RESPONSE_BYTES];
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!(pReq->Flags & SDREQ_FLAGS_DATA_TRANS) ||
|
|
|
|
|
|
+ (pReq->Flags & SDREQ_FLAGS_DATA_SKIP_RESP_CHK) ||
|
|
|
|
|
|
+ (GET_SDREQ_RESP_TYPE(pReq->Flags) == SDREQ_FLAGS_NO_RESP)) {
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ pResponse = pReq->Response;
|
|
|
|
|
|
+ /* check SPI mode */
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(pHcd)) {
|
|
|
|
|
|
+ if (!(pReq->Flags & SDREQ_FLAGS_RESP_SKIP_SPI_FILT)) {
|
|
|
|
|
|
+ /* apply conversion */
|
|
|
|
|
|
+ ConvertSPI_Response(pReq, NULL);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* temporarily convert the response, without altering the original */
|
|
|
|
|
|
+ ConvertSPI_Response(pReq, convertedResponse);
|
|
|
|
|
|
+ /* point to the converted one */
|
|
|
|
|
|
+ pResponse = convertedResponse;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ switch (GET_SDREQ_RESP_TYPE(pReq->Flags)) {
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_R1:
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_R1B:
|
|
|
|
|
|
+ cardStatus = SD_R1_GET_CARD_STATUS(pResponse);
|
|
|
|
|
|
+ if (!(cardStatus &
|
|
|
|
|
|
+ (SD_CS_ILLEGAL_CMD_ERR | SD_CS_CARD_INTERNAL_ERR | SD_CS_GENERAL_ERR))) {
|
|
|
|
|
|
+ /* okay for data */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* figure out what it was */
|
|
|
|
|
|
+ if (cardStatus & SD_CS_ILLEGAL_CMD_ERR) {
|
|
|
|
|
|
+ status = SDIO_STATUS_DATA_STATE_INVALID;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ status = SDIO_STATUS_DATA_ERROR_UNKNOWN;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Check Response Error. R1 CardStatus:0x%X \n",
|
|
|
|
|
|
+ cardStatus));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_SDIO_R5:
|
|
|
|
|
|
+ cardStatus = SD_R5_GET_RESP_FLAGS(pResponse);
|
|
|
|
|
|
+ if (!(cardStatus & SD_R5_CURRENT_CMD_ERRORS)){
|
|
|
|
|
|
+ /* all okay */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = ConvertCMD52ResponseToSDIOStatus((UINT8)cardStatus);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: Check Response Error. R5 CardStatus:0x%X \n",
|
|
|
|
|
|
+ cardStatus));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ {
|
|
|
|
|
|
+ UINT8 spiToken;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* handle SPI token validation */
|
|
|
|
|
|
+ switch (GET_SDREQ_RESP_TYPE(pReq->Flags)) {
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_R2:
|
|
|
|
|
|
+ spiToken = GET_SPI_R2_RESP_TOKEN(pReq->Response);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_SDIO_R5:
|
|
|
|
|
|
+ spiToken = GET_SPI_SDIO_R5_RESP_TOKEN(pReq->Response);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_R3:
|
|
|
|
|
|
+ spiToken = GET_SPI_R3_RESP_TOKEN(pReq->Response);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ case SDREQ_FLAGS_RESP_SDIO_R4:
|
|
|
|
|
|
+ spiToken = GET_SPI_SDIO_R4_RESP_TOKEN(pReq->Response);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ /* all other tokesn are SPI R1 type */
|
|
|
|
|
|
+ spiToken = GET_SPI_R1_RESP_TOKEN(pReq->Response);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if ((GET_SDREQ_RESP_TYPE(pReq->Flags) == SDREQ_FLAGS_RESP_SDIO_R5) ||
|
|
|
|
|
|
+ (GET_SDREQ_RESP_TYPE(pReq->Flags) == SDREQ_FLAGS_RESP_SDIO_R4)) {
|
|
|
|
|
|
+ /* handle SDIO status tokens */
|
|
|
|
|
|
+ if ((spiToken & SPI_R5_ILLEGAL_CMD) ||
|
|
|
|
|
|
+ (spiToken & SPI_R5_CMD_CRC)) {
|
|
|
|
|
|
+ status = SDIO_STATUS_BUS_RESP_TIMEOUT;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* handle all other status tokens */
|
|
|
|
|
|
+ if ((spiToken & SPI_CS_ILLEGAL_CMD) ||
|
|
|
|
|
|
+ (spiToken & SPI_CS_CMD_CRC_ERR)) {
|
|
|
|
|
|
+ status = SDIO_STATUS_BUS_RESP_TIMEOUT;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/busdriver/sdio_bus_os.c b/drivers/sdio/stack/busdriver/sdio_bus_os.c
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..dbdb955
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/busdriver/sdio_bus_os.c
|
|
|
|
|
|
@@ -0,0 +1,832 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: sdio_bus_os.c
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: Linux implementation module
|
|
|
|
|
|
+
|
|
|
|
|
|
+#notes: includes module load and unload functions
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+/* debug level for this module*/
|
|
|
|
|
|
+#define DBG_DECLARE 3;
|
|
|
|
|
|
+
|
|
|
|
|
|
+#include <linux/sdio/ctsystem.h>
|
|
|
|
|
|
+#include <linux/kernel.h>
|
|
|
|
|
|
+#include <linux/module.h>
|
|
|
|
|
|
+#include <linux/version.h>
|
|
|
|
|
|
+#include <linux/init.h>
|
|
|
|
|
|
+#include <linux/workqueue.h>
|
|
|
|
|
|
+#include <linux/delay.h>
|
|
|
|
|
|
+#include <linux/kthread.h>
|
|
|
|
|
|
+#include <linux/pnp.h>
|
|
|
|
|
|
+void pnp_remove_card_device(struct pnp_dev *dev);
|
|
|
|
|
|
+#include <linux/sdio/sdio_busdriver.h>
|
|
|
|
|
|
+#include <linux/sdio/sdio_lib.h>
|
|
|
|
|
|
+#include "_busdriver.h"
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define DESCRIPTION "SDIO Bus Driver"
|
|
|
|
|
|
+#define AUTHOR "Atheros Communications, Inc."
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* debug print parameter */
|
|
|
|
|
|
+/* configuration and default parameters */
|
|
|
|
|
|
+static int RequestRetries = SDMMC_DEFAULT_CMD_RETRIES;
|
|
|
|
|
|
+module_param(RequestRetries, int, 0644);
|
|
|
|
|
|
+MODULE_PARM_DESC(RequestRetries, "number of command retries");
|
|
|
|
|
|
+static int CardReadyPollingRetry = SDMMC_DEFAULT_CARD_READY_RETRIES;
|
|
|
|
|
|
+module_param(CardReadyPollingRetry, int, 0644);
|
|
|
|
|
|
+MODULE_PARM_DESC(CardReadyPollingRetry, "number of card ready retries");
|
|
|
|
|
|
+static int PowerSettleDelay = SDMMC_POWER_SETTLE_DELAY;
|
|
|
|
|
|
+module_param(PowerSettleDelay, int, 0644);
|
|
|
|
|
|
+MODULE_PARM_DESC(PowerSettleDelay, "delay in ms for power to settle after power changes");
|
|
|
|
|
|
+static int DefaultOperClock = 52000000;
|
|
|
|
|
|
+module_param(DefaultOperClock, int, 0644);
|
|
|
|
|
|
+MODULE_PARM_DESC(DefaultOperClock, "maximum operational clock limit");
|
|
|
|
|
|
+static int DefaultBusMode = SDCONFIG_BUS_WIDTH_4_BIT;
|
|
|
|
|
|
+module_param(DefaultBusMode, int, 0644);
|
|
|
|
|
|
+MODULE_PARM_DESC(DefaultBusMode, "default bus mode: see SDCONFIG_BUS_WIDTH_xxx");
|
|
|
|
|
|
+static int RequestListSize = SDBUS_DEFAULT_REQ_LIST_SIZE;
|
|
|
|
|
|
+module_param(RequestListSize, int, 0644);
|
|
|
|
|
|
+MODULE_PARM_DESC(RequestListSize, "");
|
|
|
|
|
|
+static int SignalSemListSize = SDBUS_DEFAULT_REQ_SIG_SIZE;
|
|
|
|
|
|
+module_param(SignalSemListSize, int, 0644);
|
|
|
|
|
|
+MODULE_PARM_DESC(SignalSemListSize, "");
|
|
|
|
|
|
+static int CDPollingInterval = SDBUS_DEFAULT_CD_POLLING_INTERVAL;
|
|
|
|
|
|
+module_param(CDPollingInterval, int, 0644);
|
|
|
|
|
|
+MODULE_PARM_DESC(CDPollingInterval, "");
|
|
|
|
|
|
+static int DefaultOperBlockLen = SDMMC_DEFAULT_BYTES_PER_BLOCK;
|
|
|
|
|
|
+module_param(DefaultOperBlockLen, int, 0644);
|
|
|
|
|
|
+MODULE_PARM_DESC(DefaultOperBlockLen, "operational block length");
|
|
|
|
|
|
+static int DefaultOperBlockCount = SDMMC_DEFAULT_BLOCKS_PER_TRANS;
|
|
|
|
|
|
+module_param(DefaultOperBlockCount, int, 0644);
|
|
|
|
|
|
+MODULE_PARM_DESC(DefaultOperBlockCount, "operational block count");
|
|
|
|
|
|
+static int ConfigFlags = BD_DEFAULT_CONFIG_FLAGS;
|
|
|
|
|
|
+module_param(ConfigFlags, int, 0644);
|
|
|
|
|
|
+MODULE_PARM_DESC(ConfigFlags, "config flags");
|
|
|
|
|
|
+
|
|
|
|
|
|
+static int HcdRCount = MAX_HCD_REQ_RECURSION;
|
|
|
|
|
|
+module_param(HcdRCount, int, 0644);
|
|
|
|
|
|
+MODULE_PARM_DESC(HcdRCount, "HCD request recursion count");
|
|
|
|
|
|
+
|
|
|
|
|
|
+static void CardDetect_WorkItem(
|
|
|
|
|
|
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
|
|
|
|
|
|
+void *context);
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+struct work_struct *ignored);
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+static void CardDetect_TimerFunc(unsigned long Context);
|
|
|
|
|
|
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
|
|
|
|
|
|
+static DECLARE_WORK(CardDetectPollWork, CardDetect_WorkItem
|
|
|
|
|
|
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
|
|
|
|
|
|
+, 0);
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+);
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+static int RegisterDriver(PSDFUNCTION pFunction);
|
|
|
|
|
|
+static int UnregisterDriver(PSDFUNCTION pFunction);
|
|
|
|
|
|
+
|
|
|
|
|
|
+static struct timer_list CardDetectTimer;
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDDEVICE_FROM_OSDEVICE(pOSDevice) container_of(pOSDevice, SDDEVICE, Device)
|
|
|
|
|
|
+#define SDFUNCTION_FROM_OSDRIVER(pOSDriver) container_of(pOSDriver, SDFUNCTION, Driver)
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * SDIO_RegisterHostController - register a host controller bus driver
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS SDIO_RegisterHostController(PSDHCD pHcd) {
|
|
|
|
|
|
+ /* we are the exported verison, call the internal verison */
|
|
|
|
|
|
+ return _SDIO_RegisterHostController(pHcd);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * SDIO_UnregisterHostController - unregister a host controller bus driver
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS SDIO_UnregisterHostController(PSDHCD pHcd) {
|
|
|
|
|
|
+ /* we are the exported verison, call the internal verison */
|
|
|
|
|
|
+ return _SDIO_UnregisterHostController(pHcd);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * SDIO_RegisterFunction - register a function driver
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS SDIO_RegisterFunction(PSDFUNCTION pFunction) {
|
|
|
|
|
|
+ int error;
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO BusDriver - SDIO_RegisterFunction\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* since we do PnP registration first, we need to check the version */
|
|
|
|
|
|
+ if (!CHECK_FUNCTION_DRIVER_VERSION(pFunction)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: Function Major Version Mismatch (hcd = %d, bus driver = %d)\n",
|
|
|
|
|
|
+ GET_SDIO_STACK_VERSION_MAJOR(pFunction), CT_SDIO_STACK_VERSION_MAJOR(g_Version)));
|
|
|
|
|
|
+ return SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* we are the exported verison, call the internal verison after registering with the bus
|
|
|
|
|
|
+ we handle probes internally to the bus driver */
|
|
|
|
|
|
+ if ((error = RegisterDriver(pFunction)) < 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO BusDriver - SDIO_RegisterFunction, failed to register with system bus driver: %d\n",
|
|
|
|
|
|
+ error));
|
|
|
|
|
|
+ status = OSErrorToSDIOError(error);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ status = _SDIO_RegisterFunction(pFunction);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ UnregisterDriver(pFunction);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * SDIO_UnregisterFunction - unregister a function driver
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS SDIO_UnregisterFunction(PSDFUNCTION pFunction) {
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ /* we are the exported verison, call the internal verison */
|
|
|
|
|
|
+ status = _SDIO_UnregisterFunction(pFunction);
|
|
|
|
|
|
+ UnregisterDriver(pFunction);
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * SDIO_HandleHcdEvent - tell core an event occurred
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS SDIO_HandleHcdEvent(PSDHCD pHcd, HCD_EVENT Event) {
|
|
|
|
|
|
+ /* we are the exported verison, call the internal verison */
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_HCD_EVENTS, ("SDIO Bus Driver: SDIO_HandleHcdEvent, event type 0x%X, HCD:0x%X\n",
|
|
|
|
|
|
+ Event, (UINT)pHcd));
|
|
|
|
|
|
+ return _SDIO_HandleHcdEvent(pHcd, Event);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* get default settings */
|
|
|
|
|
|
+SDIO_STATUS _SDIO_BusGetDefaultSettings(PBDCONTEXT pBdc)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ /* these defaults are module params */
|
|
|
|
|
|
+ pBdc->RequestRetries = RequestRetries;
|
|
|
|
|
|
+ pBdc->CardReadyPollingRetry = CardReadyPollingRetry;
|
|
|
|
|
|
+ pBdc->PowerSettleDelay = PowerSettleDelay;
|
|
|
|
|
|
+ pBdc->DefaultOperClock = DefaultOperClock;
|
|
|
|
|
|
+ pBdc->DefaultBusMode = DefaultBusMode;
|
|
|
|
|
|
+ pBdc->RequestListSize = RequestListSize;
|
|
|
|
|
|
+ pBdc->SignalSemListSize = SignalSemListSize;
|
|
|
|
|
|
+ pBdc->CDPollingInterval = CDPollingInterval;
|
|
|
|
|
|
+ pBdc->DefaultOperBlockLen = DefaultOperBlockLen;
|
|
|
|
|
|
+ pBdc->DefaultOperBlockCount = DefaultOperBlockCount;
|
|
|
|
|
|
+ pBdc->ConfigFlags = ConfigFlags;
|
|
|
|
|
|
+ pBdc->MaxHcdRecursion = HcdRCount;
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static void CardDetect_TimerFunc(unsigned long Context)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_CD_TIMER, ("+ SDIO BusDriver Card Detect Timer\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* timers run in an ISR context and cannot block or sleep, so we need
|
|
|
|
|
|
+ * to queue a work item to call the bus driver timer notification */
|
|
|
|
|
|
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
|
|
|
|
|
|
+ if (schedule_work(&CardDetectPollWork) <= 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("Failed to queue Card Detect timer!\n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+ CardDetect_WorkItem(NULL);
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_CD_TIMER, ("- SDIO BusDriver Card Detect Timer\n"));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * Initialize any timers we are using
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS InitializeTimers(void)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ init_timer(&CardDetectTimer);
|
|
|
|
|
|
+ CardDetectTimer.function = CardDetect_TimerFunc;
|
|
|
|
|
|
+ CardDetectTimer.data = 0;
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * cleanup timers
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS CleanupTimers(void)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ del_timer(&CardDetectTimer);
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * Queue a timer, Timeout is in milliseconds
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS QueueTimer(INT TimerID, UINT32 TimeOut)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ UINT32 delta;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* convert timeout to ticks */
|
|
|
|
|
|
+ delta = (TimeOut * HZ)/1000;
|
|
|
|
|
|
+ if (delta == 0) {
|
|
|
|
|
|
+ delta = 1;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_CD_TIMER, ("SDIO BusDriver - SDIO_QueueTimer System Ticks Per Sec:%d \n",HZ));
|
|
|
|
|
|
+ DBG_PRINT(SDIODBG_CD_TIMER, ("SDIO BusDriver - SDIO_QueueTimer TimerID: %d TimeOut:%d MS, requires %d Ticks\n",
|
|
|
|
|
|
+ TimerID,TimeOut,delta));
|
|
|
|
|
|
+ switch (TimerID) {
|
|
|
|
|
|
+ case SDIOBUS_CD_TIMER_ID:
|
|
|
|
|
|
+ CardDetectTimer.expires = jiffies + delta;
|
|
|
|
|
|
+ add_timer(&CardDetectTimer);
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ return SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* check a response on behalf of the host controller, to allow it to proceed with a
|
|
|
|
|
|
+ * data transfer */
|
|
|
|
|
|
+SDIO_STATUS SDIO_CheckResponse(PSDHCD pHcd, PSDREQUEST pReq, SDHCD_RESPONSE_CHECK_MODE CheckMode)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ return _SDIO_CheckResponse(pHcd,pReq,CheckMode);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * CardDetect_WorkItem - the work item for handling card detect polling interrupt
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static void CardDetect_WorkItem(
|
|
|
|
|
|
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
|
|
|
|
|
|
+void *context)
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+struct work_struct *ignored)
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ /* call bus driver function */
|
|
|
|
|
|
+ SDIO_NotifyTimerTriggered(SDIOBUS_CD_TIMER_ID);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * OS_IncHcdReference - increment host controller driver reference count
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS Do_OS_IncHcdReference(PSDHCD pHcd)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ if (NULL == pHcd->pModule) {
|
|
|
|
|
|
+ /* hcds that are 2.3 or higher should set this */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: HCD:%s should set module ptr!\n",
|
|
|
|
|
|
+ (pHcd->pName != NULL) ? pHcd->pName : "Unknown"));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
|
|
|
|
|
|
+ if (!try_module_get(pHcd->pModule)) {
|
|
|
|
|
|
+ status = SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+ if (!try_inc_mod_count(pHcd->pModule)) {
|
|
|
|
|
|
+ status = SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: HCD:%s failed to get module\n",
|
|
|
|
|
|
+ (pHcd->pName != NULL) ? pHcd->pName : "Unknown"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * OS_DecHcdReference - decrement host controller driver reference count
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS Do_OS_DecHcdReference(PSDHCD pHcd)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ if (pHcd->pModule != NULL) {
|
|
|
|
|
|
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
|
|
|
|
|
|
+ module_put(pHcd->pModule);
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+ /* 2.4 or lower */
|
|
|
|
|
|
+ __MOD_DEC_USE_COUNT(pHcd->pModule);
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/****************************************************************************************/
|
|
|
|
|
|
+
|
|
|
|
|
|
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
|
|
|
|
|
|
+#include <linux/pnp.h>
|
|
|
|
|
|
+
|
|
|
|
|
|
+#if !defined(CONFIG_PNP)
|
|
|
|
|
|
+#error "CONFIG_PNP not defined"
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+
|
|
|
|
|
|
+static ULONG InUseDevices = 0;
|
|
|
|
|
|
+static spinlock_t InUseDevicesLock = SPIN_LOCK_UNLOCKED;
|
|
|
|
|
|
+
|
|
|
|
|
|
+static const struct pnp_device_id pnp_idtable[] = {
|
|
|
|
|
|
+ {"SD_XXXX", 0}
|
|
|
|
|
|
+};
|
|
|
|
|
|
+static int sdio_get_resources(struct pnp_dev * pDev, struct pnp_resource_table * res)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - sdio_get_resources: %s\n",
|
|
|
|
|
|
+ pDev->dev.bus_id));
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+static int sdio_set_resources(struct pnp_dev * pDev, struct pnp_resource_table * res)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - sdio_set_resources: %s\n",
|
|
|
|
|
|
+ pDev->dev.bus_id));
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static int sdio_disable_resources(struct pnp_dev *pDev)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - sdio_disable_resources: %s\n",
|
|
|
|
|
|
+ pDev->dev.bus_id));
|
|
|
|
|
|
+ if (pDev != NULL) {
|
|
|
|
|
|
+ pDev->active = 0;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+void release(struct device * pDev) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - release: %s\n",
|
|
|
|
|
|
+ pDev->bus_id));
|
|
|
|
|
|
+ return;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+struct pnp_protocol sdio_protocol = {
|
|
|
|
|
|
+ .name = "SDIO",
|
|
|
|
|
|
+ .get = sdio_get_resources,
|
|
|
|
|
|
+ .set = sdio_set_resources,
|
|
|
|
|
|
+ .disable = sdio_disable_resources,
|
|
|
|
|
|
+ .dev.release = release,
|
|
|
|
|
|
+};
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * driver_probe - probe for OS based driver
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static int driver_probe(struct pnp_dev* pOSDevice, const struct pnp_device_id *pId)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSDDEVICE pDevice = SDDEVICE_FROM_OSDEVICE(pOSDevice);
|
|
|
|
|
|
+ PSDFUNCTION pFunction = pDevice->Device.dev.driver_data;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pFunction == NULL) {
|
|
|
|
|
|
+ return -1;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (strcmp(pFunction->pName, pOSDevice->dev.driver->name) == 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - driver_probe, match: %s/%s driver: %s\n",
|
|
|
|
|
|
+ pOSDevice->dev.bus_id, pFunction->pName, pOSDevice->dev.driver->name));
|
|
|
|
|
|
+ return 1;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - driver_probe, no match: %s/%s driver: %s\n",
|
|
|
|
|
|
+ pOSDevice->dev.bus_id, pFunction->pName, pOSDevice->dev.driver->name));
|
|
|
|
|
|
+ return -1;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+/* if (pOSDevice->id != NULL) {
|
|
|
|
|
|
+ if (strcmp(pOSDevice->id->id, pId->id) == 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - driver_probe, match: %s/%s\n",
|
|
|
|
|
|
+ pOSDevice->dev.bus_id, pId->id));
|
|
|
|
|
|
+ return 1;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - driver_probe, did not match: %s/%s/%s\n",
|
|
|
|
|
|
+ pOSDevice->dev.bus_id, pId->id, pOSDevice->id->id));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - driver_probe, did not match: %s/%s\n",
|
|
|
|
|
|
+ pOSDevice->dev.bus_id, pId->id));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return -1;
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+//?? if (pDevice->Device.dev.driver_data != NULL) {
|
|
|
|
|
|
+//?? if (pDevice->Device.dev.driver_data == pFunction) {
|
|
|
|
|
|
+//?? if (pDevice->Device.data != NULL) {
|
|
|
|
|
|
+//?? if (pDevice->Device.data == pFunction) {
|
|
|
|
|
|
+//?? DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+//?? ("SDIO BusDriver - driver_probe, match: %s\n",
|
|
|
|
|
|
+//?? pOSDevice->dev.bus_id));
|
|
|
|
|
|
+//?? return 1;
|
|
|
|
|
|
+//?? }
|
|
|
|
|
|
+//?? }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - driver_probe, match: %s\n",
|
|
|
|
|
|
+ pOSDevice->dev.bus_id));
|
|
|
|
|
|
+ return 1;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static int RegisterDriver(PSDFUNCTION pFunction)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ memset(&pFunction->Driver, 0, sizeof(pFunction->Driver));
|
|
|
|
|
|
+ pFunction->Driver.name = pFunction->pName;
|
|
|
|
|
|
+ pFunction->Driver.probe = driver_probe;
|
|
|
|
|
|
+ pFunction->Driver.id_table = pnp_idtable;
|
|
|
|
|
|
+ pFunction->Driver.flags = PNP_DRIVER_RES_DO_NOT_CHANGE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - SDIO_RegisterFunction, registering driver: %s\n",
|
|
|
|
|
|
+ pFunction->Driver.name));
|
|
|
|
|
|
+ return pnp_register_driver(&pFunction->Driver);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static int UnregisterDriver(PSDFUNCTION pFunction)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("+SDIO BusDriver - UnregisterDriver, driver: %s\n",
|
|
|
|
|
|
+ pFunction->Driver.name));
|
|
|
|
|
|
+ pnp_unregister_driver(&pFunction->Driver);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("-SDIO BusDriver - UnregisterDriver\n"));
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * OS_InitializeDevice - initialize device that will be registered
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS OS_InitializeDevice(PSDDEVICE pDevice, PSDFUNCTION pFunction)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ struct pnp_id *pFdname;
|
|
|
|
|
|
+ memset(&pDevice->Device, 0, sizeof(pDevice->Device));
|
|
|
|
|
|
+ pDevice->Device.dev.driver_data = (PVOID)pFunction;
|
|
|
|
|
|
+//?? pDevice->Device.data = (PVOID)pFunction;
|
|
|
|
|
|
+//?? pDevice->Device.dev.driver = &pFunction->Driver.driver;
|
|
|
|
|
|
+//?? pDevice->Device.driver = &pFunction->Driver;
|
|
|
|
|
|
+//?? pDevice->Device.dev.release = release;
|
|
|
|
|
|
+ /* get a unique device number, must be done with locks held */
|
|
|
|
|
|
+ spin_lock(&InUseDevicesLock);
|
|
|
|
|
|
+ pDevice->Device.number = FirstClearBit(&InUseDevices);
|
|
|
|
|
|
+ SetBit(&InUseDevices, pDevice->Device.number);
|
|
|
|
|
|
+ spin_unlock(&InUseDevicesLock);
|
|
|
|
|
|
+ pDevice->Device.capabilities = PNP_REMOVABLE | PNP_DISABLE;
|
|
|
|
|
|
+ pDevice->Device.protocol = &sdio_protocol;
|
|
|
|
|
|
+ pDevice->Device.active = 1;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pnp_init_resource_table(&pDevice->Device.res);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pFdname = KernelAlloc(sizeof(struct pnp_id));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (NULL == pFdname) {
|
|
|
|
|
|
+ return SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* set the id as slot number/function number */
|
|
|
|
|
|
+ snprintf(pFdname->id, sizeof(pFdname->id), "SD_%02X%02X",
|
|
|
|
|
|
+ pDevice->pHcd->SlotNumber, (UINT)SDDEVICE_GET_SDIO_FUNCNO(pDevice));
|
|
|
|
|
|
+ pFdname->next = NULL;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO BusDriver - OS_InitializeDevice adding id: %s\n",
|
|
|
|
|
|
+ pFdname->id));
|
|
|
|
|
|
+ pnp_add_id(pFdname, &pDevice->Device);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* deal with DMA settings */
|
|
|
|
|
|
+ if (pDevice->pHcd->pDmaDescription != NULL) {
|
|
|
|
|
|
+ pDevice->Device.dev.dma_mask = &pDevice->pHcd->pDmaDescription->Mask;
|
|
|
|
|
|
+ pDevice->Device.dev.coherent_dma_mask = pDevice->pHcd->pDmaDescription->Mask;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * OS_AddDevice - must be pre-initialized with OS_InitializeDevice
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS OS_AddDevice(PSDDEVICE pDevice, PSDFUNCTION pFunction)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ int error;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO BusDriver - OS_AddDevice adding function: %s\n",
|
|
|
|
|
|
+ pFunction->pName));
|
|
|
|
|
|
+ error = pnp_add_device(&pDevice->Device);
|
|
|
|
|
|
+ if (error < 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO BusDriver - OS_AddDevice failed pnp_add_device: %d\n",
|
|
|
|
|
|
+ error));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* replace the buggy pnp's release */
|
|
|
|
|
|
+ pDevice->Device.dev.release = release;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return OSErrorToSDIOError(error);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * OS_RemoveDevice - unregister device with driver and bus
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+void OS_RemoveDevice(PSDDEVICE pDevice)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO BusDriver - OS_RemoveDevice \n"));
|
|
|
|
|
|
+ pnp_remove_card_device(&pDevice->Device);
|
|
|
|
|
|
+ spin_lock(&InUseDevicesLock);
|
|
|
|
|
|
+ ClearBit(&InUseDevices, pDevice->Device.number);
|
|
|
|
|
|
+ spin_unlock(&InUseDevicesLock);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pDevice->Device.id != NULL) {
|
|
|
|
|
|
+ KernelFree(pDevice->Device.id);
|
|
|
|
|
|
+ pDevice->Device.id = NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Add OS device to bus driver.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDIO_BusAddOSDevice
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: pDma - descrip[tion of support DMA or NULL
|
|
|
|
|
|
+ @output: pDriver - assigned driver object
|
|
|
|
|
|
+ @output: pDevice - assigned device object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS - SDIO_STATUS_SUCCESS when successful.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: If the HCD does not register with the driver sub-system directly (like in the PCI case),
|
|
|
|
|
|
+ then it should register with the bus driver to obtain OS dependent device objects.
|
|
|
|
|
|
+ All input structures should be maintained throughout the life of the driver.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: getting device objects:
|
|
|
|
|
|
+ typedef struct _SDHCD_DRIVER {
|
|
|
|
|
|
+ OS_PNPDEVICE HcdDevice; / * the OS device for this HCD * /
|
|
|
|
|
|
+ OS_PNPDRIVER HcdDriver; / * the OS driver for this HCD * /
|
|
|
|
|
|
+ SDDMA_DESCRIPTION Dma; / * driver DMA description * /
|
|
|
|
|
|
+ }SDHCD_DRIVER, *PSDHCD_DRIVER;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ typedef struct _SDHCD_DRIVER_CONTEXT {
|
|
|
|
|
|
+ PTEXT pDescription; / * human readable device decsription * /
|
|
|
|
|
|
+ SDLIST DeviceList; / * the list of current devices handled by this driver * /
|
|
|
|
|
|
+ OS_SEMAPHORE DeviceListSem; / * protection for the DeviceList * /
|
|
|
|
|
|
+ UINT DeviceCount; / * number of devices currently installed * /
|
|
|
|
|
|
+ SDHCD_DRIVER Driver; / * OS dependent driver specific info * /
|
|
|
|
|
|
+ }SDHCD_DRIVER_CONTEXT, *PSDHCD_DRIVER_CONTEXT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ static SDHCD_DRIVER_CONTEXT HcdContext = {
|
|
|
|
|
|
+ .pDescription = DESCRIPTION,
|
|
|
|
|
|
+ .DeviceCount = 0,
|
|
|
|
|
|
+ .Driver.HcdDevice.name = "sdio_xxx_hcd",
|
|
|
|
|
|
+ .Driver.HcdDriver.name = "sdio_xxx_hcd",
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ .....
|
|
|
|
|
|
+ status = SDIO_BusAddOSDevice(NULL, &HcdContext.Driver, &HcdContext.Device);
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status) {
|
|
|
|
|
|
+ return Probe(&HcdContext.Device);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return SDIOErrorToOSError(status);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDIO_BusRemoveOSDevice
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS SDIO_BusAddOSDevice(PSDDMA_DESCRIPTION pDma, POS_PNPDRIVER pDriver, POS_PNPDEVICE pDevice)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ int err;
|
|
|
|
|
|
+ struct pnp_id *pFdname;
|
|
|
|
|
|
+ struct pnp_device_id *pFdid;
|
|
|
|
|
|
+ static int slotNumber = 0; /* we just use an increasing count for the slots number */
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pDma != NULL) {
|
|
|
|
|
|
+ pDevice->dev.dma_mask = &pDma->Mask;
|
|
|
|
|
|
+ pDevice->dev.coherent_dma_mask = pDma->Mask;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO BusDriver - SDIO_GetBusOSDevice, registering driver: %s DMAmask: 0x%x\n",
|
|
|
|
|
|
+ pDriver->name, (UINT)*pDevice->dev.dma_mask));
|
|
|
|
|
|
+ pFdid = KernelAlloc(sizeof(struct pnp_device_id)*2);
|
|
|
|
|
|
+ /* set the id as slot number/function number */
|
|
|
|
|
|
+ snprintf(pFdid[0].id, sizeof(pFdid[0].id), "SD_%02X08",
|
|
|
|
|
|
+ slotNumber++);
|
|
|
|
|
|
+ pFdid[0].driver_data = 0;
|
|
|
|
|
|
+ pFdid[1].id[0] = '\0';
|
|
|
|
|
|
+ pFdid[1].driver_data = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pDriver->id_table = pFdid;
|
|
|
|
|
|
+ pDriver->flags = PNP_DRIVER_RES_DO_NOT_CHANGE;
|
|
|
|
|
|
+ err = pnp_register_driver(pDriver);
|
|
|
|
|
|
+ if (err < 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO BusDriver - SDIO_GetBusOSDevice, failed registering driver: %s, err: %d\n",
|
|
|
|
|
|
+ pDriver->name, err));
|
|
|
|
|
|
+ return OSErrorToSDIOError(err);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pDevice->protocol = &sdio_protocol;
|
|
|
|
|
|
+ pDevice->capabilities = PNP_REMOVABLE | PNP_DISABLE;
|
|
|
|
|
|
+ pDevice->active = 1;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pFdname = KernelAlloc(sizeof(struct pnp_id));
|
|
|
|
|
|
+ /* set the id as slot number/function number */
|
|
|
|
|
|
+ snprintf(pFdname->id, sizeof(pFdname->id), "SD_%02X08",
|
|
|
|
|
|
+ 0); //??pDevice->pHcd->SlotNumber);//?????fix this, slotnumber isn't vaialble yet
|
|
|
|
|
|
+ pFdname->next = NULL;
|
|
|
|
|
|
+ pnp_add_id(pFdname, pDevice);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* get a unique device number */
|
|
|
|
|
|
+ spin_lock(&InUseDevicesLock);
|
|
|
|
|
|
+ pDevice->number = FirstClearBit(&InUseDevices);
|
|
|
|
|
|
+ SetBit(&InUseDevices, pDevice->number);
|
|
|
|
|
|
+ spin_unlock(&InUseDevicesLock);
|
|
|
|
|
|
+ pnp_init_resource_table(&pDevice->res);
|
|
|
|
|
|
+ err = pnp_add_device(pDevice);
|
|
|
|
|
|
+ if (err < 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO BusDriver - SDIO_GetBusOSDevice failed pnp_device_add: %d\n",
|
|
|
|
|
|
+ err));
|
|
|
|
|
|
+ pnp_unregister_driver(pDriver);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* replace the buggy pnp's release */
|
|
|
|
|
|
+ pDevice->dev.release = release;
|
|
|
|
|
|
+ return OSErrorToSDIOError(err);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Return OS device from bus driver.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDIO_BusRemoveOSDevice
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDriver - setup PNP driver object
|
|
|
|
|
|
+ @input: pDevice - setup PNP device object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: returning device objects:
|
|
|
|
|
|
+ SDIO_BusRemoveOSDevice(&HcdContext.Driver, &HcdContext.Device);
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDIO_BusAddOSDevice
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+void SDIO_BusRemoveOSDevice(POS_PNPDRIVER pDriver, POS_PNPDEVICE pDevice)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO BusDriver - SDIO_PutBusOSDevice, unregistering driver: %s\n",
|
|
|
|
|
|
+ pDriver->name));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pnp_remove_card_device(pDevice);
|
|
|
|
|
|
+ if (pDevice->id != NULL) {
|
|
|
|
|
|
+ KernelFree(pDevice->id);
|
|
|
|
|
|
+ pDevice->id = NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ spin_lock(&InUseDevicesLock);
|
|
|
|
|
|
+ ClearBit(&InUseDevices, pDevice->number);
|
|
|
|
|
|
+ spin_unlock(&InUseDevicesLock);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pnp_unregister_driver(pDriver);
|
|
|
|
|
|
+ if (pDriver->id_table != NULL) {
|
|
|
|
|
|
+ KernelFree((void *)pDriver->id_table);
|
|
|
|
|
|
+ pDriver->id_table = NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * module init
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static int __init sdio_busdriver_init(void) {
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ int error;
|
|
|
|
|
|
+ REL_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: loaded\n"));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = _SDIO_BusDriverInitialize()))) {
|
|
|
|
|
|
+ return SDIOErrorToOSError(status);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* register the sdio bus */
|
|
|
|
|
|
+ error = pnp_register_protocol(&sdio_protocol);
|
|
|
|
|
|
+ if (error < 0) {
|
|
|
|
|
|
+ REL_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: failed to register bus device, %d\n", error));
|
|
|
|
|
|
+ _SDIO_BusDriverCleanup();
|
|
|
|
|
|
+ return error;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * module cleanup
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static void __exit sdio_busdriver_cleanup(void) {
|
|
|
|
|
|
+ REL_PRINT(SDDBG_TRACE, ("SDIO unloaded\n"));
|
|
|
|
|
|
+ _SDIO_BusDriverCleanup();
|
|
|
|
|
|
+ pnp_unregister_protocol(&sdio_protocol);
|
|
|
|
|
|
+DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - unloaded 1\n"));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+EXPORT_SYMBOL(SDIO_BusAddOSDevice);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDIO_BusRemoveOSDevice);
|
|
|
|
|
|
+
|
|
|
|
|
|
+#elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
|
|
|
|
|
|
+ /* 2.4 */
|
|
|
|
|
|
+static int RegisterDriver(PSDFUNCTION pFunction)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static int UnregisterDriver(PSDFUNCTION pFunction)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("+-SDIO BusDriver - UnregisterDriver, driver: \n"));
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * OS_InitializeDevice - initialize device that will be registered
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS OS_InitializeDevice(PSDDEVICE pDevice, PSDFUNCTION pFunction)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * OS_AddDevice - must be pre-initialized with OS_InitializeDevice
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS OS_AddDevice(PSDDEVICE pDevice, PSDFUNCTION pFunction)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO BusDriver - OS_AddDevice adding function: %s\n",
|
|
|
|
|
|
+ pFunction->pName));
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * OS_RemoveDevice - unregister device with driver and bus
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+void OS_RemoveDevice(PSDDEVICE pDevice)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO BusDriver - OS_RemoveDevice \n"));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * module init
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static int __init sdio_busdriver_init(void) {
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ REL_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: loaded\n"));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = _SDIO_BusDriverInitialize()))) {
|
|
|
|
|
|
+ return SDIOErrorToOSError(status);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * module cleanup
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static void __exit sdio_busdriver_cleanup(void) {
|
|
|
|
|
|
+ REL_PRINT(SDDBG_TRACE, ("SDIO unloaded\n"));
|
|
|
|
|
|
+ _SDIO_BusDriverCleanup();
|
|
|
|
|
|
+}
|
|
|
|
|
|
+#else ////KERNEL_VERSION
|
|
|
|
|
|
+#error "unsupported kernel version: "UTS_RELEASE
|
|
|
|
|
|
+#endif //KERNEL_VERSION
|
|
|
|
|
|
+
|
|
|
|
|
|
+MODULE_LICENSE("GPL and additional rights");
|
|
|
|
|
|
+MODULE_DESCRIPTION(DESCRIPTION);
|
|
|
|
|
|
+MODULE_AUTHOR(AUTHOR);
|
|
|
|
|
|
+
|
|
|
|
|
|
+module_init(sdio_busdriver_init);
|
|
|
|
|
|
+module_exit(sdio_busdriver_cleanup);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDIO_RegisterHostController);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDIO_UnregisterHostController);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDIO_HandleHcdEvent);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDIO_CheckResponse);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDIO_RegisterFunction);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDIO_UnregisterFunction);
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/busdriver/sdio_function.c b/drivers/sdio/stack/busdriver/sdio_function.c
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..78b8e17
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/busdriver/sdio_function.c
|
|
|
|
|
|
@@ -0,0 +1,715 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: sdio_function.c
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: OS independent bus driver support for function drivers
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notes: This file supports the interface between SDIO function drivers and the bus driver.
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2005 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define MODULE_NAME SDBUSDRIVER
|
|
|
|
|
|
+#include <linux/sdio/ctsystem.h>
|
|
|
|
|
|
+#include <linux/sdio/sdio_busdriver.h>
|
|
|
|
|
|
+#include <linux/sdio/sdio_lib.h>
|
|
|
|
|
|
+#include "_busdriver.h"
|
|
|
|
|
|
+
|
|
|
|
|
|
+static SDIO_STATUS ProbeForDevice(PSDFUNCTION pFunction);
|
|
|
|
|
|
+
|
|
|
|
|
|
+#ifdef CT_MAN_CODE_CHECK
|
|
|
|
|
|
+static UINT16 ManCodeCheck = CT_MAN_CODE_CHECK;
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Register a function driver with the bus driver.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDIO_RegisterFunction
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDIO_RegisterFunction(PSDFUNCTION pFunction)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+ @input: pFunction - the function definition structure.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS - SDIO_STATUS_SUCCESS when succesful.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Each function driver must register with the bus driver once upon loading.
|
|
|
|
|
|
+ The calling function must be prepared to receive a Probe callback before
|
|
|
|
|
|
+ this function returns. This will occur when an perpheral device is already
|
|
|
|
|
|
+ pluugged in that is supported by this function.
|
|
|
|
|
|
+ The function driver should unregister itself when exiting.
|
|
|
|
|
|
+ The bus driver checks for possible function drivers to support a device
|
|
|
|
|
|
+ in reverse registration order.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Registering a function driver:
|
|
|
|
|
|
+ //list of devices supported by this function driver
|
|
|
|
|
|
+ static SD_PNP_INFO Ids[] = {
|
|
|
|
|
|
+ {.SDIO_ManufacturerID = 0xaa55,
|
|
|
|
|
|
+ .SDIO_ManufacturerCode = 0x5555,
|
|
|
|
|
|
+ .SDIO_FunctionNo = 1},
|
|
|
|
|
|
+ {} //list is null termintaed
|
|
|
|
|
|
+ };
|
|
|
|
|
|
+ static GENERIC_FUNCTION_CONTEXT FunctionContext = {
|
|
|
|
|
|
+ .Function.pName = "sdio_generic", //name of the device
|
|
|
|
|
|
+ .Function.Version = CT_SDIO_STACK_VERSION_CODE, // set stack version
|
|
|
|
|
|
+ .Function.MaxDevices = 1, //maximum number of devices supported by this driver
|
|
|
|
|
|
+ .Function.NumDevices = 0, //current number of devices, always zero to start
|
|
|
|
|
|
+ .Function.pIds = Ids, //the list of devices supported by this device
|
|
|
|
|
|
+ .Function.pProbe = Probe, //pointer to the function drivers Probe function
|
|
|
|
|
|
+ // that will be called when a possibly supported device
|
|
|
|
|
|
+ // is inserted.
|
|
|
|
|
|
+ .Function.pRemove = Remove, //pointer to the function drivers Remove function
|
|
|
|
|
|
+ / that will be called when a device is removed.
|
|
|
|
|
|
+ .Function.pContext = &FunctionContext, //data value that will be passed into Probe and
|
|
|
|
|
|
+ // Remove callbacks.
|
|
|
|
|
|
+ };
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ status = SDIO_RegisterFunction(&FunctionContext.Function)
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ ...failed to register
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDIO_UnregisterFunction
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _SDIO_RegisterFunction(PSDFUNCTION pFunction)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+#ifdef CT_MAN_CODE_CHECK
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO Bus Driver: _SDIO_RegisterFunction: WARNING, this version is locked to Memory cards and SDIO cards with JEDEC IDs of: 0x%X\n",
|
|
|
|
|
|
+ ManCodeCheck));
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: _SDIO_RegisterFunction\n"));
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: Function Driver Stack Version: %d.%d \n",
|
|
|
|
|
|
+ GET_SDIO_STACK_VERSION_MAJOR(pFunction),GET_SDIO_STACK_VERSION_MINOR(pFunction)));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!CHECK_FUNCTION_DRIVER_VERSION(pFunction)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Bus Driver: Function Major Version Mismatch (hcd = %d, bus driver = %d)\n",
|
|
|
|
|
|
+ GET_SDIO_STACK_VERSION_MAJOR(pFunction), CT_SDIO_STACK_VERSION_MAJOR(g_Version)));
|
|
|
|
|
|
+ return SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* sanity check the driver */
|
|
|
|
|
|
+ if ((pFunction == NULL) ||
|
|
|
|
|
|
+ (pFunction->pProbe == NULL) ||
|
|
|
|
|
|
+ (pFunction->pIds == NULL)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_RegisterFunction, invalid registration data\n"));
|
|
|
|
|
|
+ return SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* protect the function list and add the function */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePendInterruptable(&pBusContext->FunctionListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ SignalInitialize(&pFunction->CleanupReqSig);
|
|
|
|
|
|
+ SDLIST_INIT(&pFunction->DeviceList);
|
|
|
|
|
|
+ SDListAdd(&pBusContext->FunctionList, &pFunction->SDList);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePost(&pBusContext->FunctionListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* see if we have devices for this new function driver */
|
|
|
|
|
|
+ ProbeForDevice(pFunction);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+cleanup:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: _SDIO_RegisterFunction, error exit 0x%X\n", status));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Unregister a function driver with the bus driver.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDIO_UnregisterFunction
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDIO_UnregisterFunction(PSDFUNCTION pFunction)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pFunction - the function definition structure.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS - SDIO_STATUS_SUCCESS when succesful.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Each function driver must unregister from the bus driver when the function driver
|
|
|
|
|
|
+ exits.
|
|
|
|
|
|
+ A function driver must disconnect from any interrupts before calling this function.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Unregistering a function driver:
|
|
|
|
|
|
+ SDIO_UnregisterFunction(&FunctionContext.Function);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDIO_RegisterFunction
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _SDIO_UnregisterFunction(PSDFUNCTION pFunction)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ PSDDEVICE pDevice;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: _SDIO_UnregisterFunction\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* protect the function list and synchronize with Probe() and Remove()*/
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePendInterruptable(&pBusContext->FunctionListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* remove this function from the function list */
|
|
|
|
|
|
+ SDListRemove(&pFunction->SDList);
|
|
|
|
|
|
+ /* now remove this function as the handler for any of its devices */
|
|
|
|
|
|
+ SDITERATE_OVER_LIST_ALLOW_REMOVE(&pFunction->DeviceList, pDevice, SDDEVICE,FuncListLink) {
|
|
|
|
|
|
+ if (pDevice->pFunction == pFunction) {
|
|
|
|
|
|
+ /* notify removal */
|
|
|
|
|
|
+ NotifyDeviceRemove(pDevice);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }SDITERATE_END;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ SignalDelete(&pFunction->CleanupReqSig);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePost(&pBusContext->FunctionListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("-SDIO Bus Driver: _SDIO_UnregisterFunction\n"));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+
|
|
|
|
|
|
+cleanup:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("-SDIO Bus Driver: _SDIO_UnregisterFunction, error exit 0x%X\n", status));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* documentation headers only for Probe and Remove */
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: This function is called by the Busdriver when a device is inserted that can be supported by this function driver.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: Probe
|
|
|
|
|
|
+ @prototype: BOOL (*pProbe)(struct _SDFUNCTION *pFunction, struct _SDDEVICE *pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pFunction - the function definition structure that was passed to Busdriver
|
|
|
|
|
|
+ via the SDIO_RegisterFunction.
|
|
|
|
|
|
+ @input: pDevice - the description of the newly inserted device.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: TRUE - this function driver will suport this device
|
|
|
|
|
|
+ FALSE - this function driver will not support this device
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: The Busdriver calls the Probe function of a function driver to inform it that device is
|
|
|
|
|
|
+ available for the function driver to control. The function driver should initialize the
|
|
|
|
|
|
+ device and be pepared to acceopt any interrupts from the device before returning.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of typical Probe function callback:
|
|
|
|
|
|
+ static BOOL Probe(PSDFUNCTION pFunction, PSDDEVICE pDevice) {
|
|
|
|
|
|
+ ...get the our context info passed into the SDIO_RegisterFunction
|
|
|
|
|
|
+ PSDXXX_DRIVER_CONTEXT pFunctionContext =
|
|
|
|
|
|
+ (PSDXXX_DRIVER_CONTEXT)pFunction->pContext;
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ //test the identification of this device and ensure we want to support it
|
|
|
|
|
|
+ // we can test based on class, or use more specific tests on SDIO_ManufacturerID, etc.
|
|
|
|
|
|
+ if (pDevice->pId[0].SDIO_FunctionClass == XXX) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO XXX Function: Probe - card matched (0x%X/0x%X/0x%X)\n",
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_ManufacturerID,
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_ManufacturerCode,
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_FunctionNo));
|
|
|
|
|
|
+ ...
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDIO_RegisterFunction
|
|
|
|
|
|
+ @see also: Remove
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+BOOL FilterPnpInfo(PSDDEVICE pDevice)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+#ifdef CT_MAN_CODE_CHECK
|
|
|
|
|
|
+ if (pDevice->pId[0].CardFlags & CARD_SDIO) {
|
|
|
|
|
|
+ if (pDevice->pId[0].SDIO_ManufacturerCode != ManCodeCheck) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR,
|
|
|
|
|
|
+ ("SDIO Card with JEDEC ID:0x%X , not Allowed! Driver check halted. "
|
|
|
|
|
|
+ "Please Contact sales@codetelligence.com.\n",
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_ManufacturerCode));
|
|
|
|
|
|
+ return FALSE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return TRUE;
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+ return TRUE;
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: This function is called by the Busdriver when a device controlled by this function
|
|
|
|
|
|
+ function driver is removed.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: Remove
|
|
|
|
|
|
+ @prototype: void (*pRemove)(struct _SDFUNCTION *pFunction, struct _SDDEVICE *pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pFunction - the function definition structure that was passed to Busdriver
|
|
|
|
|
|
+ via the SDIO_RegisterFunction.
|
|
|
|
|
|
+ @input: pDevice - the description of the device being removed.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: The Busdriver calls the Remove function of a function driver to inform it that device it
|
|
|
|
|
|
+ was supporting has been removed. The device has already been removed, so no further I/O
|
|
|
|
|
|
+ to the device can be performed.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of typical Remove function callback:
|
|
|
|
|
|
+ void Remove(PSDFUNCTION pFunction, PSDDEVICE pDevice) {
|
|
|
|
|
|
+ // get the our context info passed into the SDIO_RegisterFunction
|
|
|
|
|
|
+ PSDXXX_DRIVER_CONTEXT pFunctionContext =
|
|
|
|
|
|
+ (PSDXXX_DRIVER_CONTEXT)pFunction->pContext;
|
|
|
|
|
|
+ ...free any acquired resources.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDIO_RegisterFunction
|
|
|
|
|
|
+ @see also: Probe
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * ProbeForFunction - look for a function driver to handle this card
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS ProbeForFunction(PSDDEVICE pDevice, PSDHCD pHcd) {
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ PSDLIST pList;
|
|
|
|
|
|
+ PSDFUNCTION pFunction;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: ProbeForFunction\n"));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: ProbeForFunction - Dump of Device PNP Data: \n"));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" Card Flags 0x%X \n", pDevice->pId[0].CardFlags));
|
|
|
|
|
|
+ if (pDevice->pId[0].CardFlags & CARD_SDIO) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" SDIO MANF: 0x%X \n", pDevice->pId[0].SDIO_ManufacturerID));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" SDIO MANFCODE: 0x%X \n", pDevice->pId[0].SDIO_ManufacturerCode));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" SDIO FuncNo: %d \n", pDevice->pId[0].SDIO_FunctionNo));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" SDIO FuncClass: %d \n", pDevice->pId[0].SDIO_FunctionClass));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (pDevice->pId[0].CardFlags & (CARD_MMC | CARD_SD)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" SDMMC MANFID: 0x%X \n",pDevice->pId[0].SDMMC_ManfacturerID));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" SDMMC OEMID: 0x%X \n",pDevice->pId[0].SDMMC_OEMApplicationID));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!FilterPnpInfo(pDevice)) {
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ goto cleanup;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* protect the function list */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePendInterruptable(&pBusContext->FunctionListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* protect against ProbeForDevice */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePendInterruptable(&pBusContext->DeviceListSem)))) {
|
|
|
|
|
|
+ /* release the function list semaphore we just took */
|
|
|
|
|
|
+ SemaphorePost(&pBusContext->FunctionListSem);
|
|
|
|
|
|
+ goto cleanup;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (pDevice->pFunction != NULL) {
|
|
|
|
|
|
+ /* device already has a function driver handling it */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: ProbeForFunction, device already has function\n"));
|
|
|
|
|
|
+ /* release function list */
|
|
|
|
|
|
+ SemaphorePost(&pBusContext->DeviceListSem);
|
|
|
|
|
|
+ /* release function list */
|
|
|
|
|
|
+ SemaphorePost(&pBusContext->FunctionListSem);
|
|
|
|
|
|
+ /* just return success */
|
|
|
|
|
|
+ status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ goto cleanup;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* release device list */
|
|
|
|
|
|
+ SemaphorePost(&pBusContext->DeviceListSem);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* walk functions looking for one that can handle this device */
|
|
|
|
|
|
+ SDITERATE_OVER_LIST(&pBusContext->FunctionList, pList) {
|
|
|
|
|
|
+ pFunction = CONTAINING_STRUCT(pList, SDFUNCTION, SDList);
|
|
|
|
|
|
+ if (pFunction->NumDevices >= pFunction->MaxDevices) {
|
|
|
|
|
|
+ /* function can't support any more devices */
|
|
|
|
|
|
+ continue;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: ProbeForFunction - checking: %s \n",
|
|
|
|
|
|
+ pFunction->pName));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* see if this function handles this device */
|
|
|
|
|
|
+ if (IsPotentialIdMatch(pDevice->pId, pFunction->pIds)) {
|
|
|
|
|
|
+ if (!FilterPnpInfo(pDevice)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: ProbeForFunction -Got Match, probing: %s \n",
|
|
|
|
|
|
+ pFunction->pName));
|
|
|
|
|
|
+ /* we need to setup with the OS bus driver before the probe, so probe can
|
|
|
|
|
|
+ do OS operations. */
|
|
|
|
|
|
+ OS_InitializeDevice(pDevice, pFunction);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(OS_AddDevice(pDevice, pFunction))) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* close enough match, ask the function driver if it supports us */
|
|
|
|
|
|
+ if (pFunction->pProbe(pFunction, pDevice)) {
|
|
|
|
|
|
+ /* she accepted the device, add to list */
|
|
|
|
|
|
+ pDevice->pFunction = pFunction;
|
|
|
|
|
|
+ SDListAdd(&pFunction->DeviceList, &pDevice->FuncListLink);
|
|
|
|
|
|
+ pFunction->NumDevices++;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: %s did not claim the device \n",
|
|
|
|
|
|
+ pFunction->pName));
|
|
|
|
|
|
+ /* didn't take this device */
|
|
|
|
|
|
+ OS_RemoveDevice(pDevice);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePost(&pBusContext->FunctionListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("-SDIO Bus Driver: ProbeForFunction\n"));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+cleanup:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: ProbeForFunction, error exit 0x%X\n", status));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * ProbeForDevice - look for a device that this function driver supports
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static SDIO_STATUS ProbeForDevice(PSDFUNCTION pFunction) {
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ PSDLIST pList;
|
|
|
|
|
|
+ PSDDEVICE pDevice;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: ProbeForDevice\n"));
|
|
|
|
|
|
+ if (pFunction->NumDevices >= pFunction->MaxDevices) {
|
|
|
|
|
|
+ /* function can't support any more devices */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: ProbeForDevice, too many devices in function\n"));
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* protect the driver list */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePendInterruptable(&pBusContext->DeviceListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* walk device list */
|
|
|
|
|
|
+ SDITERATE_OVER_LIST(&pBusContext->DeviceList, pList) {
|
|
|
|
|
|
+ pDevice = CONTAINING_STRUCT(pList, SDDEVICE, SDList);
|
|
|
|
|
|
+ if (pDevice->pFunction != NULL) {
|
|
|
|
|
|
+ /* device already has a function driver handling it */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: ProbeForDevice, device already has function\n"));
|
|
|
|
|
|
+ continue;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* see if this function handles this device */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: ProbeForDevice, matching ID:%d %d class:%d\n",
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_ManufacturerID,
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_FunctionNo,
|
|
|
|
|
|
+ pDevice->pId[0].SDIO_FunctionClass));
|
|
|
|
|
|
+ if (IsPotentialIdMatch(pDevice->pId, pFunction->pIds)) {
|
|
|
|
|
|
+ if (!FilterPnpInfo(pDevice)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* we need to setup with the OS bus driver before the probe, so probe can
|
|
|
|
|
|
+ do OS operations. */
|
|
|
|
|
|
+ OS_InitializeDevice(pDevice, pFunction);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(OS_AddDevice(pDevice, pFunction))) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* close enough match, ask the function driver if it supports us */
|
|
|
|
|
|
+ if (pFunction->pProbe(pFunction, pDevice)) {
|
|
|
|
|
|
+ /* she accepted the device, add to list */
|
|
|
|
|
|
+ pDevice->pFunction = pFunction;
|
|
|
|
|
|
+ SDListAdd(&pFunction->DeviceList, &pDevice->FuncListLink);
|
|
|
|
|
|
+ pFunction->NumDevices++;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_WARN, ("SDIO Bus Driver: %s did not claim the device \n",
|
|
|
|
|
|
+ pFunction->pName));
|
|
|
|
|
|
+ /* didn't take this device */
|
|
|
|
|
|
+ OS_RemoveDevice(pDevice);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePost(&pBusContext->DeviceListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+cleanup:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: ProbeForDevice, error exit 0x%X\n", status));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+#if 0
|
|
|
|
|
|
+static void DumpPnpEntry(PSD_PNP_INFO pInfo)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("Function PnpInfo Dump: \n"));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" Card Flags 0x%X \n", pInfo->CardFlags));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" SDIO MANF: 0x%X \n", pInfo->SDIO_ManufacturerID));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" SDIO MANFCODE: 0x%X \n", pInfo->SDIO_ManufacturerCode));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" SDIO FuncNo: %d \n", pInfo->SDIO_FunctionNo));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" SDIO FuncClass: %d \n", pInfo->SDIO_FunctionClass));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" SDMMC MANFID: 0x%X \n", pInfo->SDMMC_ManfacturerID));
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, (" SDMMC OEMID: 0x%X \n", pInfo->SDMMC_OEMApplicationID));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * IsPotentialIdMatch - test for potential device match
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+BOOL IsPotentialIdMatch(PSD_PNP_INFO pIdsDev, PSD_PNP_INFO pIdsFuncList) {
|
|
|
|
|
|
+ PSD_PNP_INFO pTFn;
|
|
|
|
|
|
+ BOOL match = FALSE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ for (pTFn = pIdsFuncList;!IS_LAST_SDPNPINFO_ENTRY(pTFn);pTFn++) {
|
|
|
|
|
|
+ //DumpPnpEntry(pTFn);
|
|
|
|
|
|
+ /* check specific SDIO Card manufacturer ID, Code and Function number */
|
|
|
|
|
|
+ if ((pIdsDev->SDIO_ManufacturerID != 0) &&
|
|
|
|
|
|
+ (pTFn->SDIO_ManufacturerID != 0) &&
|
|
|
|
|
|
+ (pIdsDev->SDIO_ManufacturerID == pTFn->SDIO_ManufacturerID) &&
|
|
|
|
|
|
+ (pIdsDev->SDIO_ManufacturerCode == pTFn->SDIO_ManufacturerCode) &&
|
|
|
|
|
|
+ ((pIdsDev->SDIO_FunctionNo == pTFn->SDIO_FunctionNo) ||
|
|
|
|
|
|
+ (pTFn->SDIO_FunctionNo == 0)) ) {
|
|
|
|
|
|
+ match = TRUE;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* check generic function class */
|
|
|
|
|
|
+ if ((pIdsDev->SDIO_FunctionClass != 0) &&
|
|
|
|
|
|
+ (pTFn->SDIO_FunctionClass != 0) &&
|
|
|
|
|
|
+ (pIdsDev->SDIO_FunctionClass == pTFn->SDIO_FunctionClass)) {
|
|
|
|
|
|
+ match = TRUE;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* check specific SDMMC MANFID and APPLICATION ID, NOTE SANDISK
|
|
|
|
|
|
+ * uses a MANFID of zero! */
|
|
|
|
|
|
+ if ((pTFn->SDMMC_OEMApplicationID != 0) &&
|
|
|
|
|
|
+ (pIdsDev->SDMMC_ManfacturerID == pTFn->SDMMC_ManfacturerID) &&
|
|
|
|
|
|
+ (pIdsDev->SDMMC_OEMApplicationID == pTFn->SDMMC_OEMApplicationID)) {
|
|
|
|
|
|
+ match = TRUE;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check generic SD Card */
|
|
|
|
|
|
+ if ((pIdsDev->CardFlags & CARD_SD) &&
|
|
|
|
|
|
+ (pTFn->CardFlags & CARD_SD)){
|
|
|
|
|
|
+ match = TRUE;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check generic MMC Card */
|
|
|
|
|
|
+ if ((pIdsDev->CardFlags & CARD_MMC) &&
|
|
|
|
|
|
+ (pTFn->CardFlags & CARD_MMC)){
|
|
|
|
|
|
+ match = TRUE;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* check raw Card */
|
|
|
|
|
|
+ if ((pIdsDev->CardFlags & CARD_RAW) &&
|
|
|
|
|
|
+ (pTFn->CardFlags & CARD_RAW)){
|
|
|
|
|
|
+ match = TRUE;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return match;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * NotifyDeviceRemove - tell function driver on this device that the device is being removed
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS NotifyDeviceRemove(PSDDEVICE pDevice) {
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ SDREQUESTQUEUE cancelQueue;
|
|
|
|
|
|
+ PSDREQUEST pReq;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ InitializeRequestQueue(&cancelQueue);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if ((pDevice->pFunction != NULL) &&
|
|
|
|
|
|
+ (pDevice->pFunction->pRemove != NULL)){
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: removing device 0x%X\n", (INT)pDevice));
|
|
|
|
|
|
+ /* fail any outstanding requests for this device */
|
|
|
|
|
|
+ /* acquire lock for request queue */
|
|
|
|
|
|
+ status = _AcquireHcdLock(pDevice->pHcd);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* mark the function to block any more requests comming down */
|
|
|
|
|
|
+ pDevice->pFunction->Flags |= SDFUNCTION_FLAG_REMOVING;
|
|
|
|
|
|
+ /* walk through HCD queue and remove this function's requests */
|
|
|
|
|
|
+ SDITERATE_OVER_LIST_ALLOW_REMOVE(&pDevice->pHcd->RequestQueue.Queue, pReq, SDREQUEST, SDList) {
|
|
|
|
|
|
+ if (pReq->pFunction == pDevice->pFunction) {
|
|
|
|
|
|
+ /* cancel this request, as this device or function is being removed */
|
|
|
|
|
|
+ /* note that these request are getting completed out of order */
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver - NotifyDeviceRemove: canceling req 0x%X\n", (UINT)pReq));
|
|
|
|
|
|
+ pReq->Status = SDIO_STATUS_CANCELED;
|
|
|
|
|
|
+ /* remove it from the HCD queue */
|
|
|
|
|
|
+ SDListRemove(&pReq->SDList);
|
|
|
|
|
|
+ /* add it to the cancel queue */
|
|
|
|
|
|
+ QueueRequest(&cancelQueue, pReq);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }SDITERATE_END;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pDevice->pHcd);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* now empty the cancel queue if anything is in there */
|
|
|
|
|
|
+ while (TRUE) {
|
|
|
|
|
|
+ pReq = DequeueRequest(&cancelQueue);
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* complete the request */
|
|
|
|
|
|
+ DoRequestCompletion(pReq, pDevice->pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* re-acquire the lock to deal with the current request */
|
|
|
|
|
|
+ status = _AcquireHcdLock(pDevice->pHcd);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* now deal with the current request */
|
|
|
|
|
|
+ pReq = GET_CURRENT_REQUEST(pDevice->pHcd);
|
|
|
|
|
|
+ if ((pReq !=NULL) && (pReq->pFunction == pDevice->pFunction) && (pReq->pFunction != NULL)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver - NotifyDeviceRemove: Outstanding Req 0x%X on HCD: 0x%X.. waiting...\n",
|
|
|
|
|
|
+ (UINT)pReq, (UINT)pDevice->pHcd));
|
|
|
|
|
|
+ /* the outstanding request on this device is for the function being removed */
|
|
|
|
|
|
+ pReq->Flags |= SDREQ_FLAGS_CANCELED;
|
|
|
|
|
|
+ /* wait for this request to get completed normally */
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pDevice->pHcd);
|
|
|
|
|
|
+ SignalWait(&pDevice->pFunction->CleanupReqSig);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver - NotifyDeviceRemove: Outstanding HCD Req 0x%X completed \n", (UINT)pReq));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* release lock */
|
|
|
|
|
|
+ status = _ReleaseHcdLock(pDevice->pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* synchronize with ISR SYNC Handlers */
|
|
|
|
|
|
+ status = SemaphorePendInterruptable(&pBusContext->DeviceListSem);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* call this devices Remove function */
|
|
|
|
|
|
+ pDevice->pFunction->pRemove(pDevice->pFunction,pDevice);
|
|
|
|
|
|
+ pDevice->pFunction->NumDevices--;
|
|
|
|
|
|
+ /* make sure the sync handler is NULLed out */
|
|
|
|
|
|
+ pDevice->pIrqFunction = NULL;
|
|
|
|
|
|
+ SemaphorePost(&pBusContext->DeviceListSem);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ OS_RemoveDevice(pDevice);
|
|
|
|
|
|
+ /* detach this device from the function list it belongs to */
|
|
|
|
|
|
+ SDListRemove(&pDevice->FuncListLink);
|
|
|
|
|
|
+ pDevice->pFunction->Flags &= ~SDFUNCTION_FLAG_REMOVING;
|
|
|
|
|
|
+ pDevice->pFunction = NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * RemoveHcdFunctions - remove all functions attached to an HCD
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS RemoveHcdFunctions(PSDHCD pHcd) {
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ PSDLIST pList;
|
|
|
|
|
|
+ PSDFUNCTION pFunction;
|
|
|
|
|
|
+ PSDDEVICE pDevice;
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("+SDIO Bus Driver: RemoveHcdFunctions\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* walk through the functions and remove the ones associated with this HCD */
|
|
|
|
|
|
+ /* protect the driver list */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePend(&pBusContext->FunctionListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* mark that card is being removed */
|
|
|
|
|
|
+ pHcd->CardProperties.CardState |= CARD_STATE_REMOVED;
|
|
|
|
|
|
+ SDITERATE_OVER_LIST(&pBusContext->FunctionList, pList) {
|
|
|
|
|
|
+ pFunction = CONTAINING_STRUCT(pList, SDFUNCTION, SDList);
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Bus Driver: scanning function 0x%X, %s\n", (INT)pFunction,
|
|
|
|
|
|
+ (pFunction == NULL)?"NULL":pFunction->pName));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* walk the devices on this function and look for a match */
|
|
|
|
|
|
+ SDITERATE_OVER_LIST_ALLOW_REMOVE(&pFunction->DeviceList, pDevice, SDDEVICE,FuncListLink) {
|
|
|
|
|
|
+ if (pDevice->pHcd == pHcd) {
|
|
|
|
|
|
+ /* match, remove it */
|
|
|
|
|
|
+ NotifyDeviceRemove(pDevice);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ SDITERATE_END;
|
|
|
|
|
|
+ SDITERATE_END;
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePost(&pBusContext->FunctionListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("-SDIO Bus Driver: RemoveHcdFunctions\n"));
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+cleanup:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("-SDIO Bus Driver: RemoveHcdFunctions, error exit 0x%X\n", status));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * RemoveAllFunctions - remove all functions attached
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS RemoveAllFunctions()
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ PSDLIST pList;
|
|
|
|
|
|
+ PSDHCD pHcd;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* walk through the HCDs */
|
|
|
|
|
|
+ /* protect the driver list */
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePend(&pBusContext->HcdListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ SDITERATE_OVER_LIST(&pBusContext->HcdList, pList) {
|
|
|
|
|
|
+ pHcd = CONTAINING_STRUCT(pList, SDHCD, SDList);
|
|
|
|
|
|
+ /* remove the functions */
|
|
|
|
|
|
+ RemoveHcdFunctions(pHcd);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (!SDIO_SUCCESS((status = SemaphorePost(&pBusContext->HcdListSem)))) {
|
|
|
|
|
|
+ goto cleanup; /* wait interrupted */
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+cleanup:
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDIO Bus Driver: RemoveAllFunctions, error exit 0x%X\n", status));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/lib/Makefile b/drivers/sdio/stack/lib/Makefile
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..44fa038
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/lib/Makefile
|
|
|
|
|
|
@@ -0,0 +1,2 @@
|
|
|
|
|
|
+obj-$(CONFIG_SDIO) += sdio_lib.o
|
|
|
|
|
|
+sdio_lib-objs := sdio_lib_c.o sdio_lib_os.o
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/lib/_sdio_lib.h b/drivers/sdio/stack/lib/_sdio_lib.h
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..28762b0
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/lib/_sdio_lib.h
|
|
|
|
|
|
@@ -0,0 +1,50 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: _sdio_lib.h
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: SDIO Lib internal include
|
|
|
|
|
|
+
|
|
|
|
|
|
+#notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#ifndef ___SDIO_LIB_H___
|
|
|
|
|
|
+#define ___SDIO_LIB_H___
|
|
|
|
|
|
+
|
|
|
|
|
|
+#endif /* ___SDIO_LIB_H___*/
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/lib/sdio_lib_c.c b/drivers/sdio/stack/lib/sdio_lib_c.c
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..4bc5a83
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/lib/sdio_lib_c.c
|
|
|
|
|
|
@@ -0,0 +1,908 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: sdio_lib_c.c
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: OS independent SDIO library functions
|
|
|
|
|
|
+@category abstract: Support_Reference Support Functions.
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notes: Support functions for device I/O
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2005 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define MODULE_NAME SDLIB_
|
|
|
|
|
|
+
|
|
|
|
|
|
+#include <linux/sdio/ctsystem.h>
|
|
|
|
|
|
+#include <linux/sdio/sdio_busdriver.h>
|
|
|
|
|
|
+#include <linux/sdio/_sdio_defs.h>
|
|
|
|
|
|
+#include <linux/sdio/sdio_lib.h>
|
|
|
|
|
|
+#include "_sdio_lib.h"
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define _Cmd52WriteByteCommon(pDev, Address, pValue) \
|
|
|
|
|
|
+ _SDLIB_IssueCMD52((pDev),0,(Address),(pValue),1,TRUE)
|
|
|
|
|
|
+#define _Cmd52ReadByteCommon(pDev, Address, pValue) \
|
|
|
|
|
|
+ _SDLIB_IssueCMD52((pDev),0,(Address),pValue,1,FALSE)
|
|
|
|
|
|
+#define _Cmd52ReadMultipleCommon(pDev, Address, pBuf,length) \
|
|
|
|
|
|
+ _SDLIB_IssueCMD52((pDev),0,(Address),(pBuf),(length),FALSE)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* inline version */
|
|
|
|
|
|
+static INLINE void _iSDLIB_SetupCMD52Request(UINT8 FuncNo,
|
|
|
|
|
|
+ UINT32 Address,
|
|
|
|
|
|
+ BOOL Write,
|
|
|
|
|
|
+ UINT8 WriteData,
|
|
|
|
|
|
+ PSDREQUEST pRequest) {
|
|
|
|
|
|
+ if (Write) {
|
|
|
|
|
|
+ SDIO_SET_CMD52_ARG(pRequest->Argument,CMD52_WRITE,
|
|
|
|
|
|
+ FuncNo,
|
|
|
|
|
|
+ CMD52_NORMAL_WRITE,Address,WriteData);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ SDIO_SET_CMD52_ARG(pRequest->Argument,CMD52_READ,FuncNo,0,Address,0x00);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pRequest->Flags = SDREQ_FLAGS_RESP_SDIO_R5;
|
|
|
|
|
|
+ pRequest->Command = CMD52;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Setup cmd52 requests
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_SetupCMD52Request
|
|
|
|
|
|
+ @prototype: void SDLIB_SetupCMD52Request(UINT8 FuncNo,
|
|
|
|
|
|
+ UINT32 Address,
|
|
|
|
|
|
+ BOOL Write,
|
|
|
|
|
|
+ UINT8 WriteData,
|
|
|
|
|
|
+ PSDREQUEST pRequest)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: FunctionNo - function number.
|
|
|
|
|
|
+ @input: Address - I/O address, 17-bit register address.
|
|
|
|
|
|
+ @input: Write - TRUE if a write operation, FALSE for reads.
|
|
|
|
|
|
+ @input: WriteData - write data, byte to write if write operation.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: pRequest - request is updated with cmd52 parameters
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This function does not perform any I/O. For register reads, the completion
|
|
|
|
|
|
+ routine can use the SD_R5_GET_READ_DATA() macro to extract the register value.
|
|
|
|
|
|
+ The routine should also extract the response flags using the SD_R5_GET_RESP_FLAGS()
|
|
|
|
|
|
+ macro and check the flags with the SD_R5_ERRORS mask.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Getting the register value from the completion routine:
|
|
|
|
|
|
+ flags = SD_R5_GET_RESP_FLAGS(pRequest->Response);
|
|
|
|
|
|
+ if (flags & SD_R5_ERRORS) {
|
|
|
|
|
|
+ ... errors
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ registerValue = SD_R5_GET_READ_DATA(pRequest->Response);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_IssueCMD52
|
|
|
|
|
|
+ @see also: SDDEVICE_CALL_REQUEST_FUNC
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+void _SDLIB_SetupCMD52Request(UINT8 FuncNo,
|
|
|
|
|
|
+ UINT32 Address,
|
|
|
|
|
|
+ BOOL Write,
|
|
|
|
|
|
+ UINT8 WriteData,
|
|
|
|
|
|
+ PSDREQUEST pRequest)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ _iSDLIB_SetupCMD52Request(FuncNo,Address,Write,WriteData,pRequest);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Issue a CMD52 to read or write a register
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_IssueCMD52
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDLIB_IssueCMD52(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT8 FuncNo,
|
|
|
|
|
|
+ UINT32 Address,
|
|
|
|
|
|
+ PUINT8 pData,
|
|
|
|
|
|
+ INT ByteCount,
|
|
|
|
|
|
+ BOOL Write)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+ @input: pDevice - the device that is the target of the command.
|
|
|
|
|
|
+ @input: FunctionNo - function number of the target.
|
|
|
|
|
|
+ @input: Address - 17-bit register address.
|
|
|
|
|
|
+ @input: ByteCount - number of bytes to read or write,
|
|
|
|
|
|
+ @input: Write - TRUE if a write operation, FALSE for reads.
|
|
|
|
|
|
+ @input: pData - data buffer for writes.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: pData - data buffer for writes.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This function will allocate a request and issue multiple byte reads or writes
|
|
|
|
|
|
+ to satisfy the ByteCount requested. This function is fully synchronous and will block
|
|
|
|
|
|
+ the caller.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_SetupCMD52Request
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _SDLIB_IssueCMD52(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT8 FuncNo,
|
|
|
|
|
|
+ UINT32 Address,
|
|
|
|
|
|
+ PUINT8 pData,
|
|
|
|
|
|
+ INT ByteCount,
|
|
|
|
|
|
+ BOOL Write)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ PSDREQUEST pReq = NULL;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ pReq = SDDeviceAllocRequest(pDevice);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ return SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ while (ByteCount) {
|
|
|
|
|
|
+ _iSDLIB_SetupCMD52Request(FuncNo,Address,Write,*pData,pReq);
|
|
|
|
|
|
+ status = SDDEVICE_CALL_REQUEST_FUNC(pDevice,pReq);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = ConvertCMD52ResponseToSDIOStatus(SD_R5_GET_RESP_FLAGS(pReq->Response));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Library: CMD52 resp error: 0x%X \n",
|
|
|
|
|
|
+ SD_R5_GET_RESP_FLAGS(pReq->Response)));
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (!Write) {
|
|
|
|
|
|
+ /* store the byte */
|
|
|
|
|
|
+ *pData = SD_R5_GET_READ_DATA(pReq->Response);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ pData++;
|
|
|
|
|
|
+ Address++;
|
|
|
|
|
|
+ ByteCount--;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ SDDeviceFreeRequest(pDevice,pReq);
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Find a device's tuple.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_FindTuple
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDLIB_FindTuple(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT8 Tuple,
|
|
|
|
|
|
+ UINT32 *pTupleScanAddress,
|
|
|
|
|
|
+ PUINT8 pBuffer,
|
|
|
|
|
|
+ UINT8 *pLength)
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+ @input: pDevice - the device that is the target of the command.
|
|
|
|
|
|
+ @input: Tuple - 8-bit ID of tuple to find
|
|
|
|
|
|
+ @input: pTupleScanAddress - On entry pTupleScanAddress is the adddress to start scanning
|
|
|
|
|
|
+ @input: pLength - length of pBuffer
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: pBuffer - storage for tuple
|
|
|
|
|
|
+ @output: pTupleScanAddress - address of the next tuple
|
|
|
|
|
|
+ @output: pLength - length of tuple read
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: It is possible to have the same tuple ID multiple times with different lengths. This function
|
|
|
|
|
|
+ blocks and is fully synchronous.
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _SDLIB_FindTuple(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT8 Tuple,
|
|
|
|
|
|
+ UINT32 *pTupleScanAddress,
|
|
|
|
|
|
+ PUINT8 pBuffer,
|
|
|
|
|
|
+ UINT8 *pLength)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ UINT32 scanStart = *pTupleScanAddress;
|
|
|
|
|
|
+ UINT8 tupleCode;
|
|
|
|
|
|
+ UINT8 tupleLink;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* sanity check */
|
|
|
|
|
|
+ if (scanStart < SDIO_CIS_AREA_BEGIN) {
|
|
|
|
|
|
+ return SDIO_STATUS_CIS_OUT_OF_RANGE;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ while (TRUE) {
|
|
|
|
|
|
+ /* check for end */
|
|
|
|
|
|
+ if (scanStart > SDIO_CIS_AREA_END) {
|
|
|
|
|
|
+ status = SDIO_STATUS_TUPLE_NOT_FOUND;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* get the code */
|
|
|
|
|
|
+ status = _Cmd52ReadByteCommon(pDevice, scanStart, &tupleCode);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (CISTPL_END == tupleCode) {
|
|
|
|
|
|
+ /* found the end */
|
|
|
|
|
|
+ status = SDIO_STATUS_TUPLE_NOT_FOUND;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* bump past tuple code */
|
|
|
|
|
|
+ scanStart++;
|
|
|
|
|
|
+ /* get the tuple link value */
|
|
|
|
|
|
+ status = _Cmd52ReadByteCommon(pDevice, scanStart, &tupleLink);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* bump past tuple link*/
|
|
|
|
|
|
+ scanStart++;
|
|
|
|
|
|
+ /* check tuple we just found */
|
|
|
|
|
|
+ if (tupleCode == Tuple) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE, ("SDIO Library: Tuple:0x%2.2X Found at Address:0x%X, TupleLink:0x%X \n",
|
|
|
|
|
|
+ Tuple, (scanStart - 2), tupleLink));
|
|
|
|
|
|
+ if (tupleLink != CISTPL_LINK_END) {
|
|
|
|
|
|
+ /* return the next scan address to the caller */
|
|
|
|
|
|
+ *pTupleScanAddress = scanStart + tupleLink;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* the tuple link is an end marker */
|
|
|
|
|
|
+ *pTupleScanAddress = 0xFFFFFFFF;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* go get the tuple */
|
|
|
|
|
|
+ status = _Cmd52ReadMultipleCommon(pDevice, scanStart,pBuffer,min(*pLength,tupleLink));
|
|
|
|
|
|
+ if (SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ /* set the actual return length */
|
|
|
|
|
|
+ *pLength = min(*pLength,tupleLink);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* break out of loop */
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /*increment past this entire tuple */
|
|
|
|
|
|
+ scanStart += tupleLink;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Issue an SDIO configuration command.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_IssueConfig
|
|
|
|
|
|
+ @prototype: SDIO_STATUS _SDLIB_IssueConfig(PSDDEVICE pDevice,
|
|
|
|
|
|
+ SDCONFIG_COMMAND Command,
|
|
|
|
|
|
+ PVOID pData,
|
|
|
|
|
|
+ INT Length)
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+ @input: pDevice - the device that is the target of the command.
|
|
|
|
|
|
+ @input: Command - command to send, see example.
|
|
|
|
|
|
+ @input: pData - command's data
|
|
|
|
|
|
+ @input: Length length of pData
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: pData - updated on commands that return data.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Command and data pairs:
|
|
|
|
|
|
+ Type Data
|
|
|
|
|
|
+ SDCONFIG_GET_WP SDCONFIG_WP_VALUE
|
|
|
|
|
|
+ SDCONFIG_SEND_INIT_CLOCKS none
|
|
|
|
|
|
+ SDCONFIG_SDIO_INT_CTRL SDCONFIG_SDIO_INT_CTRL_DATA
|
|
|
|
|
|
+ SDCONFIG_SDIO_REARM_INT none
|
|
|
|
|
|
+ SDCONFIG_BUS_MODE_CTRL SDCONFIG_BUS_MODE_DATA
|
|
|
|
|
|
+ SDCONFIG_POWER_CTRL SDCONFIG_POWER_CTRL_DATA
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _SDLIB_IssueConfig(PSDDEVICE pDevice,
|
|
|
|
|
|
+ SDCONFIG_COMMAND Command,
|
|
|
|
|
|
+ PVOID pData,
|
|
|
|
|
|
+ INT Length)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDCONFIG configHdr;
|
|
|
|
|
|
+ SET_SDCONFIG_CMD_INFO(&configHdr,Command,pData,Length);
|
|
|
|
|
|
+ return SDDEVICE_CALL_CONFIG_FUNC(pDevice,&configHdr);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Set function block size
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_SetFunctionBlockSize
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDLIB_SetFunctionBlockSize(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT16 BlockSize)
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+ @input: pDevice - the device that is the target of the command.
|
|
|
|
|
|
+ @input: BlockSize - block size to set in function
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO Status
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Issues CMD52 to set the block size. This function is fully synchronous and may
|
|
|
|
|
|
+ block.
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _SDLIB_SetFunctionBlockSize(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT16 BlockSize)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ UINT8 data[2];
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* endian safe */
|
|
|
|
|
|
+ data[0] = (UINT8)BlockSize;
|
|
|
|
|
|
+ data[1] = (UINT8)(BlockSize >> 8);
|
|
|
|
|
|
+ /* write the function blk size control register */
|
|
|
|
|
|
+ return _SDLIB_IssueCMD52(pDevice,
|
|
|
|
|
|
+ 0, /* function 0 register space */
|
|
|
|
|
|
+ FBR_FUNC_BLK_SIZE_LOW_OFFSET(CalculateFBROffset(
|
|
|
|
|
|
+ SDDEVICE_GET_SDIO_FUNCNO(pDevice))),
|
|
|
|
|
|
+ data,
|
|
|
|
|
|
+ 2,
|
|
|
|
|
|
+ TRUE);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Print a buffer to the debug output
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_PrintBuffer
|
|
|
|
|
|
+ @prototype: void SDLIB_PrintBuffer(PUCHAR pBuffer, INT Length, PTEXT pDescription)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pBuffer - Hex buffer to be printed.
|
|
|
|
|
|
+ @input: Length - length of pBuffer.
|
|
|
|
|
|
+ @input: pDescription - String title to be printed above the dump.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Prints the buffer by converting to ASCII and using REL_PRINT() with 16
|
|
|
|
|
|
+ bytes per line.
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+void _SDLIB_PrintBuffer(PUCHAR pBuffer, INT Length, PTEXT pDescription)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ TEXT line[49];
|
|
|
|
|
|
+ TEXT address[5];
|
|
|
|
|
|
+ TEXT ascii[17];
|
|
|
|
|
|
+ TEXT temp[5];
|
|
|
|
|
|
+ INT i;
|
|
|
|
|
|
+ UCHAR num;
|
|
|
|
|
|
+ USHORT offset = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ REL_PRINT(0,
|
|
|
|
|
|
+ ("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"));
|
|
|
|
|
|
+ if (pDescription != NULL) {
|
|
|
|
|
|
+ REL_PRINT(0, ("Description: %s \n\n",pDescription));
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ REL_PRINT(0, ("Description: NONE \n\n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ REL_PRINT(0,
|
|
|
|
|
|
+ ("Offset Data ASCII \n"));
|
|
|
|
|
|
+ REL_PRINT(0,
|
|
|
|
|
|
+ ("--------------------------------------------------------------------------\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ while (Length) {
|
|
|
|
|
|
+ line[0] = (TEXT)0;
|
|
|
|
|
|
+ ascii[0] = (TEXT)0;
|
|
|
|
|
|
+ address[0] = (TEXT)0;
|
|
|
|
|
|
+ sprintf(address,"%4.4X",offset);
|
|
|
|
|
|
+ for (i = 0; i < 16; i++) {
|
|
|
|
|
|
+ if (Length != 0) {
|
|
|
|
|
|
+ num = *pBuffer;
|
|
|
|
|
|
+ sprintf(temp,"%2.2X ",num);
|
|
|
|
|
|
+ strcat(line,temp);
|
|
|
|
|
|
+ if ((num >= 0x20) && (num <= 0x7E)) {
|
|
|
|
|
|
+ sprintf(temp,"%c",*pBuffer);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ sprintf(temp,"%c",0x2e);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ strcat(ascii,temp);
|
|
|
|
|
|
+ pBuffer++;
|
|
|
|
|
|
+ Length--;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ /* pad partial line with spaces */
|
|
|
|
|
|
+ strcat(line," ");
|
|
|
|
|
|
+ strcat(ascii," ");
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ REL_PRINT(0,("%s %s %s\n", address, line, ascii));
|
|
|
|
|
|
+ offset += 16;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ REL_PRINT(0,
|
|
|
|
|
|
+ ("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"));
|
|
|
|
|
|
+
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get default operational current
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_GetDefaultOpCurrent
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDLIB_GetDefaultOpCurrent(PSDDEVICE pDevice, SD_SLOT_CURRENT *pOpCurrent)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the device that is the target of the command.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: pOpCurrent - operational current in mA.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This routine reads the function's CISTPL_FUNCE tuple for the default operational
|
|
|
|
|
|
+ current. For SDIO 1.0 devices this value is read from the 8-bit TPLFE_OP_MAX_PWR
|
|
|
|
|
|
+ field. For SDIO 1.1 devices, the HP MAX power field is used only if the device is
|
|
|
|
|
|
+ operating in HIPWR mode. Otherwise the 8-bit TPLFE_OP_MAX_PWR field is used.
|
|
|
|
|
|
+ Some systems may restrict high power/current mode and force cards to operate in a
|
|
|
|
|
|
+ legacy (< 200mA) mode. This function is fully synchronous and will block the caller.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Getting the default operational current for this function:
|
|
|
|
|
|
+ // get default operational current
|
|
|
|
|
|
+ status = SDLIB_GetDefaultOpCurrent(pDevice, &slotCurrent);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ .. failed
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _SDLIB_GetDefaultOpCurrent(PSDDEVICE pDevice, SD_SLOT_CURRENT *pOpCurrent)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ UINT32 nextTpl;
|
|
|
|
|
|
+ UINT8 tplLength;
|
|
|
|
|
|
+ struct SDIO_FUNC_EXT_FUNCTION_TPL_1_1 funcTuple;
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* get the FUNCE tuple */
|
|
|
|
|
|
+ nextTpl = SDDEVICE_GET_SDIO_FUNC_CISPTR(pDevice);
|
|
|
|
|
|
+ tplLength = sizeof(funcTuple);
|
|
|
|
|
|
+ /* go get the function Extension tuple */
|
|
|
|
|
|
+ status = _SDLIB_FindTuple(pDevice,
|
|
|
|
|
|
+ CISTPL_FUNCE,
|
|
|
|
|
|
+ &nextTpl,
|
|
|
|
|
|
+ (PUINT8)&funcTuple,
|
|
|
|
|
|
+ &tplLength);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("SDLIB_GetDefaultOpCurrent: Failed to get FuncE Tuple: %d \n", status));
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* use the operational power (8-bit) value of current in mA as default*/
|
|
|
|
|
|
+ *pOpCurrent = funcTuple.CommonInfo.OpMaxPwr;
|
|
|
|
|
|
+ if ((tplLength >= sizeof(funcTuple)) && (SDDEVICE_IS_SDIO_REV_GTEQ_1_10(pDevice))) {
|
|
|
|
|
|
+ /* we have a 1.1 tuple */
|
|
|
|
|
|
+ /* check for HIPWR mode */
|
|
|
|
|
|
+ if (SDDEVICE_GET_CARD_FLAGS(pDevice) & CARD_HIPWR) {
|
|
|
|
|
|
+ /* use the maximum operational power (16 bit ) from the tuple */
|
|
|
|
|
|
+ *pOpCurrent = CT_LE16_TO_CPU_ENDIAN(funcTuple.HiPwrMaxPwr);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE void FreeMessageBlock(PSDMESSAGE_QUEUE pQueue, PSDMESSAGE_BLOCK pMsg) {
|
|
|
|
|
|
+ SDListInsertHead(&pQueue->FreeMessageList, &pMsg->SDList);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+static INLINE void QueueMessageBlock(PSDMESSAGE_QUEUE pQueue, PSDMESSAGE_BLOCK pMsg) {
|
|
|
|
|
|
+ SDListInsertTail(&pQueue->MessageList, &pMsg->SDList);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+static INLINE void QueueMessageToHead(PSDMESSAGE_QUEUE pQueue, PSDMESSAGE_BLOCK pMsg) {
|
|
|
|
|
|
+ SDListInsertHead(&pQueue->MessageList, &pMsg->SDList);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE PSDMESSAGE_BLOCK GetFreeMessageBlock(PSDMESSAGE_QUEUE pQueue) {
|
|
|
|
|
|
+ PSDLIST pItem = SDListRemoveItemFromHead(&pQueue->FreeMessageList);
|
|
|
|
|
|
+ if (pItem != NULL) {
|
|
|
|
|
|
+ return CONTAINING_STRUCT(pItem, SDMESSAGE_BLOCK , SDList);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return NULL;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+static INLINE PSDMESSAGE_BLOCK GetQueuedMessage(PSDMESSAGE_QUEUE pQueue) {
|
|
|
|
|
|
+ PSDLIST pItem = SDListRemoveItemFromHead(&pQueue->MessageList);
|
|
|
|
|
|
+ if (pItem != NULL) {
|
|
|
|
|
|
+ return CONTAINING_STRUCT(pItem, SDMESSAGE_BLOCK , SDList);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return NULL;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Create a message queue
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_CreateMessageQueue
|
|
|
|
|
|
+ @prototype: PSDMESSAGE_QUEUE SDLIB_CreateMessageQueue(INT MaxMessages, INT MaxMessageLength)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: MaxMessages - Maximum number of messages this queue supports
|
|
|
|
|
|
+ @input: MaxMessageLength - Maximum size of each message
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: Message queue object, NULL on failure
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This function creates a simple first-in-first-out message queue. The caller must determine
|
|
|
|
|
|
+ the maximum number of messages the queue supports and the size of each message. This
|
|
|
|
|
|
+ function will pre-allocate memory for each message. A producer of data posts a message
|
|
|
|
|
|
+ using SDLIB_PostMessage with a user defined data structure. A consumer of this data
|
|
|
|
|
|
+ can retrieve the message (in FIFO order) using SDLIB_GetMessage. A message queue does not
|
|
|
|
|
|
+ provide a signaling mechanism for notifying a consumer of data. Notifying a consumer is
|
|
|
|
|
|
+ user defined.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_DeleteMessageQueue, SDLIB_GetMessage, SDLIB_PostMessage.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Creating a message queue:
|
|
|
|
|
|
+ typedef struct _MyMessage {
|
|
|
|
|
|
+ UINT8 Code;
|
|
|
|
|
|
+ PVOID pDataBuffer;
|
|
|
|
|
|
+ } MyMessage;
|
|
|
|
|
|
+ // create message queue, 16 messages max.
|
|
|
|
|
|
+ pMsgQueue = SDLIB_CreateMessageQueue(16,sizeof(MyMessage));
|
|
|
|
|
|
+ if (NULL == pMsgQueue) {
|
|
|
|
|
|
+ .. failed
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+PSDMESSAGE_QUEUE _CreateMessageQueue(INT MaxMessages, INT MaxMessageLength)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSDMESSAGE_QUEUE pQueue = NULL;
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ INT ii;
|
|
|
|
|
|
+ PSDMESSAGE_BLOCK pMsg;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ pQueue = (PSDMESSAGE_QUEUE)KernelAlloc(sizeof(SDMESSAGE_QUEUE));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (NULL == pQueue) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ SDLIST_INIT(&pQueue->MessageList);
|
|
|
|
|
|
+ SDLIST_INIT(&pQueue->FreeMessageList);
|
|
|
|
|
|
+ pQueue->MaxMessageLength = MaxMessageLength;
|
|
|
|
|
|
+ status = CriticalSectionInit(&pQueue->MessageCritSection);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* allocate message blocks */
|
|
|
|
|
|
+ for (ii = 0; ii < MaxMessages; ii++) {
|
|
|
|
|
|
+ pMsg = (PSDMESSAGE_BLOCK)KernelAlloc(sizeof(SDMESSAGE_BLOCK) + MaxMessageLength -1);
|
|
|
|
|
|
+ if (NULL == pMsg) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ FreeMessageBlock(pQueue, pMsg);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (0 == ii) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ if (pQueue != NULL) {
|
|
|
|
|
|
+ _DeleteMessageQueue(pQueue);
|
|
|
|
|
|
+ pQueue = NULL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return pQueue;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Delete a message queue
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_DeleteMessageQueue
|
|
|
|
|
|
+ @prototype: void SDLIB_DeleteMessageQueue(PSDMESSAGE_QUEUE pQueue)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pQueue - message queue to delete
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This function flushes the message queue and frees all memory allocated for
|
|
|
|
|
|
+ messages.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_CreateMessageQueue
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Deleting a message queue:
|
|
|
|
|
|
+ if (pMsgQueue != NULL) {
|
|
|
|
|
|
+ SDLIB_DeleteMessageQueue(pMsgQueue);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+void _DeleteMessageQueue(PSDMESSAGE_QUEUE pQueue)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ PSDMESSAGE_BLOCK pMsg;
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CriticalSectionAcquireSyncIrq(&pQueue->MessageCritSection);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* cleanup free list */
|
|
|
|
|
|
+ while (1) {
|
|
|
|
|
|
+ pMsg = GetFreeMessageBlock(pQueue);
|
|
|
|
|
|
+ if (pMsg != NULL) {
|
|
|
|
|
|
+ KernelFree(pMsg);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* cleanup any in the queue */
|
|
|
|
|
|
+ while (1) {
|
|
|
|
|
|
+ pMsg = GetQueuedMessage(pQueue);
|
|
|
|
|
|
+ if (pMsg != NULL) {
|
|
|
|
|
|
+ KernelFree(pMsg);
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CriticalSectionReleaseSyncIrq(&pQueue->MessageCritSection);
|
|
|
|
|
|
+ CriticalSectionDelete(&pQueue->MessageCritSection);
|
|
|
|
|
|
+ KernelFree(pQueue);
|
|
|
|
|
|
+
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Post a message queue
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_PostMessage
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDLIB_PostMessage(PSDMESSAGE_QUEUE pQueue, PVOID pMessage, INT MessageLength)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pQueue - message queue to post to
|
|
|
|
|
|
+ @input: pMessage - message to post
|
|
|
|
|
|
+ @input: MessageLength - length of message (for validation)
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: The message queue uses an internal list of user defined message structures. When
|
|
|
|
|
|
+ posting a message the message is copied into an allocated structure and queued. The memory
|
|
|
|
|
|
+ pointed to by pMessage does not need to be allocated and can reside on the stack.
|
|
|
|
|
|
+ The length of the message to post can be smaller that the maximum message size. This allows
|
|
|
|
|
|
+ for variable length messages up to the maximum message size. This
|
|
|
|
|
|
+ function returns SDIO_STATUS_NO_RESOURCES, if the message queue is full. This
|
|
|
|
|
|
+ function returns SDIO_STATUS_BUFFER_TOO_SMALL, if the message size exceeds the maximum
|
|
|
|
|
|
+ size of a message. Posting and getting messsages from a message queue is safe in any
|
|
|
|
|
|
+ driver context.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_CreateMessageQueue , SDLIB_GetMessage
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Posting a message
|
|
|
|
|
|
+ MyMessage message;
|
|
|
|
|
|
+ // set up message
|
|
|
|
|
|
+ message.code = MESSAGE_DATA_READY;
|
|
|
|
|
|
+ message.pData = pInstance->pDataBuffers[currentIndex];
|
|
|
|
|
|
+ // post message
|
|
|
|
|
|
+ status = SDLIB_PostMessage(pInstance->pReadQueue,&message,sizeof(message));
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ // failed
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _PostMessage(PSDMESSAGE_QUEUE pQueue, PVOID pMessage, INT MessageLength)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status2;
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ PSDMESSAGE_BLOCK pMsg;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (MessageLength > pQueue->MaxMessageLength) {
|
|
|
|
|
|
+ return SDIO_STATUS_BUFFER_TOO_SMALL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CriticalSectionAcquireSyncIrq(&pQueue->MessageCritSection);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ /* get a message block */
|
|
|
|
|
|
+ pMsg = GetFreeMessageBlock(pQueue);
|
|
|
|
|
|
+ if (NULL == pMsg) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* copy the message */
|
|
|
|
|
|
+ memcpy(pMsg->MessageStart,pMessage,MessageLength);
|
|
|
|
|
|
+ /* set the length of the message */
|
|
|
|
|
|
+ pMsg->MessageLength = MessageLength;
|
|
|
|
|
|
+ /* queue the message to the list */
|
|
|
|
|
|
+ QueueMessageBlock(pQueue,pMsg);
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status2 = CriticalSectionReleaseSyncIrq(&pQueue->MessageCritSection);
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get a message from a message queue
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_GetMessage
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDLIB_GetMessage(PSDMESSAGE_QUEUE pQueue, PVOID pData, INT *pBufferLength)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pQueue - message queue to retreive a message from
|
|
|
|
|
|
+ @input: pBufferLength - on entry, the length of the data buffer
|
|
|
|
|
|
+ @output: pData - buffer to hold the message
|
|
|
|
|
|
+ @output: pBufferLength - on return, contains the number of bytes copied
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: The message queue uses an internal list of user defined message structures. The message is
|
|
|
|
|
|
+ dequeued (FIFO order) and copied to the callers buffer. The internal allocation for the message
|
|
|
|
|
|
+ is returned back to the message queue. This function returns SDIO_STATUS_NO_MORE_MESSAGES
|
|
|
|
|
|
+ if the message queue is empty. If the length of the buffer is smaller than the length of
|
|
|
|
|
|
+ the message at the head of the queue,this function returns SDIO_STATUS_BUFFER_TOO_SMALL and
|
|
|
|
|
|
+ returns the required length in pBufferLength.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_CreateMessageQueue , SDLIB_PostMessage
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Getting a message
|
|
|
|
|
|
+ MyMessage message;
|
|
|
|
|
|
+ INT length;
|
|
|
|
|
|
+ // set length
|
|
|
|
|
|
+ length = sizeof(message);
|
|
|
|
|
|
+ // post message
|
|
|
|
|
|
+ status = SDLIB_GetMessage(pInstance->pReadQueue,&message,&length);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ // failed
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Checking queue for a message and getting the size of the message
|
|
|
|
|
|
+ INT length;
|
|
|
|
|
|
+ // use zero length to get the size of the message
|
|
|
|
|
|
+ length = 0;
|
|
|
|
|
|
+ status = SDLIB_GetMessage(pInstance->pReadQueue,NULL,&length);
|
|
|
|
|
|
+ if (status == SDIO_STATUS_NO_MORE_MESSAGES) {
|
|
|
|
|
|
+ // no messages in queue
|
|
|
|
|
|
+ } else if (status == SDIO_STATUS_BUFFER_TOO_SMALL) {
|
|
|
|
|
|
+ // message exists in queue and length of message is returned
|
|
|
|
|
|
+ messageSizeInQueue = length;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ // some other failure
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+SDIO_STATUS _GetMessage(PSDMESSAGE_QUEUE pQueue, PVOID pData, INT *pBufferLength)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status2;
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ PSDMESSAGE_BLOCK pMsg;
|
|
|
|
|
|
+ CT_DECLARE_IRQ_SYNC_CONTEXT();
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status = CriticalSectionAcquireSyncIrq(&pQueue->MessageCritSection);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ pMsg = GetQueuedMessage(pQueue);
|
|
|
|
|
|
+ if (NULL == pMsg) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_MORE_MESSAGES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (*pBufferLength < pMsg->MessageLength) {
|
|
|
|
|
|
+ /* caller buffer is too small */
|
|
|
|
|
|
+ *pBufferLength = pMsg->MessageLength;
|
|
|
|
|
|
+ /* stick it back to the front */
|
|
|
|
|
|
+ QueueMessageToHead(pQueue, pMsg);
|
|
|
|
|
|
+ status = SDIO_STATUS_BUFFER_TOO_SMALL;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* copy the message to the callers buffer */
|
|
|
|
|
|
+ memcpy(pData,pMsg->MessageStart,pMsg->MessageLength);
|
|
|
|
|
|
+ /* return actual length */
|
|
|
|
|
|
+ *pBufferLength = pMsg->MessageLength;
|
|
|
|
|
|
+ /* return this message block back to the free list */
|
|
|
|
|
|
+ FreeMessageBlock(pQueue, pMsg);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ status2 = CriticalSectionReleaseSyncIrq(&pQueue->MessageCritSection);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* the following documents the OS helper APIs */
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Create an OS-specific helper task/thread
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_OSCreateHelper
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDLIB_OSCreateHelper(POSKERNEL_HELPER pHelper,
|
|
|
|
|
|
+ PHELPER_FUNCTION pFunction,
|
|
|
|
|
|
+ PVOID pContext)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pHelper - caller allocated helper object
|
|
|
|
|
|
+ @input: pFunction - helper function
|
|
|
|
|
|
+ @input: pContext - helper context
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This function creates a helper task/thread that runs in a new execution context. The newly
|
|
|
|
|
|
+ created task/thread invokes the helper function. The thread/task exits when the helper
|
|
|
|
|
|
+ function returns. The helper function has the prototype of:
|
|
|
|
|
|
+ THREAD_RETURN HelperFunction(POSKERNEL_HELPER pHelper)
|
|
|
|
|
|
+ The helper function usually implements a while loop and suspends execution using
|
|
|
|
|
|
+ SD_WAIT_FOR_WAKEUP(). On exit the helper function can return an OS-specific THREAD_RETURN
|
|
|
|
|
|
+ code (usually zero). The helper function executes in a fully schedule-able context and
|
|
|
|
|
|
+ can block on semaphores and sleep.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_OSDeleteHelper , SD_WAIT_FOR_WAKEUP
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: A thread helper function:
|
|
|
|
|
|
+ THREAD_RETURN HelperFunction(POSKERNEL_HELPER pHelper)
|
|
|
|
|
|
+ {
|
|
|
|
|
|
+ SDIO_STATUS status;
|
|
|
|
|
|
+ PMYCONTEXT pContext = (PMYCONTEXT)SD_GET_OS_HELPER_CONTEXT(pHelper);
|
|
|
|
|
|
+ // wait for wake up
|
|
|
|
|
|
+ while(1) {
|
|
|
|
|
|
+ status = SD_WAIT_FOR_WAKEUP(pHelper);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SD_IS_HELPER_SHUTTING_DOWN(pHelper)) {
|
|
|
|
|
|
+ //... shutting down
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ // handle wakeup...
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Creating a helper:
|
|
|
|
|
|
+ status = SDLIB_OSCreateHelper(&pInstance->OSHelper,HelperFunction,pInstance);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ // failed
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+/**++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Delete an OS helper task/thread
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_OSDeleteHelper
|
|
|
|
|
|
+ @prototype: void SDLIB_OSDeleteHelper(POSKERNEL_HELPER pHelper)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pHelper - caller allocated helper object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This function wakes the helper and waits(blocks) until the helper exits. The caller can
|
|
|
|
|
|
+ only pass an OS helper structure that was initialized sucessfully by
|
|
|
|
|
|
+ SDLIB_OSCreateHelper. The caller must be in a schedulable context.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_OSCreateHelper
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Deleting a helper:
|
|
|
|
|
|
+ if (pInstance->HelperCreated) {
|
|
|
|
|
|
+ // clean up the helper if we successfully created it
|
|
|
|
|
|
+ SDLIB_OSDeleteHelper(&pInstance->OSHelper);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/lib/sdio_lib_os.c b/drivers/sdio/stack/lib/sdio_lib_os.c
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..55363d0
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/lib/sdio_lib_os.c
|
|
|
|
|
|
@@ -0,0 +1,251 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: sdio_function_os.c
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: Linux implementation module for SDIO library
|
|
|
|
|
|
+
|
|
|
|
|
|
+#notes: includes module load and unload functions
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+/* debug level for this module*/
|
|
|
|
|
|
+#define DBG_DECLARE 4;
|
|
|
|
|
|
+#include <linux/sdio/ctsystem.h>
|
|
|
|
|
|
+
|
|
|
|
|
|
+#include <linux/module.h>
|
|
|
|
|
|
+#include <linux/init.h>
|
|
|
|
|
|
+#include <linux/kthread.h>
|
|
|
|
|
|
+
|
|
|
|
|
|
+#include <linux/sdio/sdio_busdriver.h>
|
|
|
|
|
|
+#include <linux/sdio/sdio_lib.h>
|
|
|
|
|
|
+#include "_sdio_lib.h"
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define DESCRIPTION "SDIO Kernel Library"
|
|
|
|
|
|
+#define AUTHOR "Atheros Communications, Inc."
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* proxies */
|
|
|
|
|
|
+SDIO_STATUS SDLIB_IssueCMD52(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT8 FuncNo,
|
|
|
|
|
|
+ UINT32 Address,
|
|
|
|
|
|
+ PUINT8 pData,
|
|
|
|
|
|
+ INT ByteCount,
|
|
|
|
|
|
+ BOOL Write)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ return _SDLIB_IssueCMD52(pDevice,FuncNo,Address,pData,ByteCount,Write);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_FindTuple(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT8 Tuple,
|
|
|
|
|
|
+ UINT32 *pTupleScanAddress,
|
|
|
|
|
|
+ PUINT8 pBuffer,
|
|
|
|
|
|
+ UINT8 *pLength)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ return _SDLIB_FindTuple(pDevice,Tuple,pTupleScanAddress,pBuffer,pLength);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_IssueConfig(PSDDEVICE pDevice,
|
|
|
|
|
|
+ SDCONFIG_COMMAND Command,
|
|
|
|
|
|
+ PVOID pData,
|
|
|
|
|
|
+ INT Length)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ return _SDLIB_IssueConfig(pDevice,Command,pData,Length);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+void SDLIB_PrintBuffer(PUCHAR pBuffer,INT Length,PTEXT pDescription)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ _SDLIB_PrintBuffer(pBuffer,Length,pDescription);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_SetFunctionBlockSize(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT16 BlockSize)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ return _SDLIB_SetFunctionBlockSize(pDevice,BlockSize);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+void SDLIB_SetupCMD52Request(UINT8 FuncNo,
|
|
|
|
|
|
+ UINT32 Address,
|
|
|
|
|
|
+ BOOL Write,
|
|
|
|
|
|
+ UINT8 WriteData,
|
|
|
|
|
|
+ PSDREQUEST pRequest)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ _SDLIB_SetupCMD52Request(FuncNo,Address,Write,WriteData,pRequest);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_GetDefaultOpCurrent(PSDDEVICE pDevice, SD_SLOT_CURRENT *pOpCurrent)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ return _SDLIB_GetDefaultOpCurrent(pDevice,pOpCurrent);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* helper function launcher */
|
|
|
|
|
|
+INT HelperLaunch(PVOID pContext)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ INT exit;
|
|
|
|
|
|
+ /* call function */
|
|
|
|
|
|
+ exit = ((POSKERNEL_HELPER)pContext)->pHelperFunc((POSKERNEL_HELPER)pContext);
|
|
|
|
|
|
+ complete_and_exit(&((POSKERNEL_HELPER)pContext)->Completion, exit);
|
|
|
|
|
|
+ return exit;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * OSCreateHelper - create a worker kernel thread
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+SDIO_STATUS SDLIB_OSCreateHelper(POSKERNEL_HELPER pHelper,
|
|
|
|
|
|
+ PHELPER_FUNCTION pFunction,
|
|
|
|
|
|
+ PVOID pContext)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ SDIO_STATUS status = SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ memset(pHelper,0,sizeof(OSKERNEL_HELPER));
|
|
|
|
|
|
+
|
|
|
|
|
|
+ do {
|
|
|
|
|
|
+ pHelper->pContext = pContext;
|
|
|
|
|
|
+ pHelper->pHelperFunc = pFunction;
|
|
|
|
|
|
+ status = SignalInitialize(&pHelper->WakeSignal);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ init_completion(&pHelper->Completion);
|
|
|
|
|
|
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
|
|
|
|
|
|
+ pHelper->pTask = kthread_create(HelperLaunch,
|
|
|
|
|
|
+ (PVOID)pHelper,
|
|
|
|
|
|
+ "SDIO Helper");
|
|
|
|
|
|
+ if (NULL == pHelper->pTask) {
|
|
|
|
|
|
+ status = SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ wake_up_process(pHelper->pTask);
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+ /* 2.4 */
|
|
|
|
|
|
+ pHelper->pTask = kernel_thread(HelperLaunch,
|
|
|
|
|
|
+ (PVOID)pHelper,
|
|
|
|
|
|
+ (CLONE_FS | CLONE_FILES | SIGCHLD));
|
|
|
|
|
|
+ if (pHelper->pTask < 0) {
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_TRACE,
|
|
|
|
|
|
+ ("SDIO BusDriver - OSCreateHelper, failed to create thread\n"));
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+
|
|
|
|
|
|
+ } while (FALSE);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ SDLIB_OSDeleteHelper(pHelper);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * OSDeleteHelper - delete thread created with OSCreateHelper
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+void SDLIB_OSDeleteHelper(POSKERNEL_HELPER pHelper)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+
|
|
|
|
|
|
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
|
|
|
|
|
|
+ if (pHelper->pTask != NULL) {
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+ /* 2.4 */
|
|
|
|
|
|
+ if (pHelper->pTask >= 0) {
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+ pHelper->ShutDown = TRUE;
|
|
|
|
|
|
+ SignalSet(&pHelper->WakeSignal);
|
|
|
|
|
|
+ /* wait for thread to exit */
|
|
|
|
|
|
+ wait_for_completion(&pHelper->Completion);
|
|
|
|
|
|
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
|
|
|
|
|
|
+ pHelper->pTask = NULL;
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+ /* 2.4 */
|
|
|
|
|
|
+ pHelper->pTask = 0;
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ SignalDelete(&pHelper->WakeSignal);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * module init
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static int __init sdio_lib_init(void) {
|
|
|
|
|
|
+ REL_PRINT(SDDBG_TRACE, ("SDIO Library load\n"));
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * module cleanup
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static void __exit sdio_lib_cleanup(void) {
|
|
|
|
|
|
+ REL_PRINT(SDDBG_TRACE, ("SDIO Library unload\n"));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+PSDMESSAGE_QUEUE SDLIB_CreateMessageQueue(INT MaxMessages, INT MaxMessageLength)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ return _CreateMessageQueue(MaxMessages,MaxMessageLength);
|
|
|
|
|
|
+
|
|
|
|
|
|
+}
|
|
|
|
|
|
+void SDLIB_DeleteMessageQueue(PSDMESSAGE_QUEUE pQueue)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ _DeleteMessageQueue(pQueue);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_PostMessage(PSDMESSAGE_QUEUE pQueue, PVOID pMessage, INT MessageLength)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ return _PostMessage(pQueue,pMessage,MessageLength);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_GetMessage(PSDMESSAGE_QUEUE pQueue, PVOID pData, INT *pBufferLength)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ return _GetMessage(pQueue,pData,pBufferLength);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+MODULE_LICENSE("GPL and additional rights");
|
|
|
|
|
|
+MODULE_DESCRIPTION(DESCRIPTION);
|
|
|
|
|
|
+MODULE_AUTHOR(AUTHOR);
|
|
|
|
|
|
+module_init(sdio_lib_init);
|
|
|
|
|
|
+module_exit(sdio_lib_cleanup);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_IssueCMD52);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_FindTuple);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_IssueConfig);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_PrintBuffer);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_SetFunctionBlockSize);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_SetupCMD52Request);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_GetDefaultOpCurrent);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_OSCreateHelper);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_OSDeleteHelper);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_CreateMessageQueue);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_DeleteMessageQueue);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_PostMessage);
|
|
|
|
|
|
+EXPORT_SYMBOL(SDLIB_GetMessage);
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/platform/Makefile b/drivers/sdio/stack/platform/Makefile
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..14b3612
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/platform/Makefile
|
|
|
|
|
|
@@ -0,0 +1,2 @@
|
|
|
|
|
|
+obj-$(CONFIG_SDIO) += sdio_platform.o
|
|
|
|
|
|
+sdio_platform-objs := sdioplatformdriver.o
|
|
|
|
|
|
\ No newline at end of file
|
|
|
|
|
|
diff --git a/drivers/sdio/stack/platform/sdioplatformdriver.c b/drivers/sdio/stack/platform/sdioplatformdriver.c
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..d5520fc
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/drivers/sdio/stack/platform/sdioplatformdriver.c
|
|
|
|
|
|
@@ -0,0 +1,300 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: sdioplatformdriver.c
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: Linux implementation module for SDIO pltaform driver
|
|
|
|
|
|
+
|
|
|
|
|
|
+#notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+@license: 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 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define DESCRIPTION "SDIO Platform Driver"
|
|
|
|
|
|
+#define AUTHOR "Atheros Communications, Inc."
|
|
|
|
|
|
+
|
|
|
|
|
|
+//??for .h
|
|
|
|
|
|
+
|
|
|
|
|
|
+struct sdioplatform_peripheral {
|
|
|
|
|
|
+ struct list_head node;
|
|
|
|
|
|
+ struct sdioplatform_controller *controller;
|
|
|
|
|
|
+ struct device dev;
|
|
|
|
|
|
+};
|
|
|
|
|
|
+struct sdioplatform_driver {
|
|
|
|
|
|
+ struct device_driver drv;
|
|
|
|
|
|
+ int (*probe)(struct sdioplatform_peripheral *);
|
|
|
|
|
|
+ void (*remove)(struct sdioplatform_peripheral *);
|
|
|
|
|
|
+ int (*suspend)(struct sdioplatform_peripheral *, pm_message_t);
|
|
|
|
|
|
+ int (*resume)(struct sdioplatform_peripheral *);
|
|
|
|
|
|
+};
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+struct sdioplatform_controller {
|
|
|
|
|
|
+ struct device *dev;
|
|
|
|
|
|
+};
|
|
|
|
|
|
+struct sdioplatform_controller_driver {
|
|
|
|
|
|
+ struct device_driver drv;
|
|
|
|
|
|
+ int (*probe)(struct sdioplatform_controller *);
|
|
|
|
|
|
+ void (*remove)(struct sdioplatform_controller *);
|
|
|
|
|
|
+ int (*suspend)(struct sdioplatform_controller *, pm_message_t);
|
|
|
|
|
|
+ int (*resume)(struct sdioplatform_controller *);
|
|
|
|
|
|
+};
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define device_to_sdioplatform_peripheral(d) container_of(d, struct sdioplatform_peripheral, dev)
|
|
|
|
|
|
+#define driver_to_sdioplatform_driver(d) container_of(d, struct sdioplatform_driver, drv)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define device_to_sdioplatform_controller(d) container_of(d, struct sdioplatform_controller, dev)
|
|
|
|
|
|
+#define driver_to_sdioplatform_controller_driver(d) container_of(d, struct sdioplatform_controller_driver, drv)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDIOPLATFORM_ATTR(name, fmt, args...) \
|
|
|
|
|
|
+static ssize_t sdio_##name##_show (struct device *dev, struct device_attribute *attr, char *buf) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ struct sdioplatform_peripheral *peripheral = device_to_sdioplatform_peripheral(dev); \
|
|
|
|
|
|
+ return sprintf(buf, fmt, args); \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIOPLATFORM_ATTR(bus_id, "%s\n", bus_id);
|
|
|
|
|
|
+#define SDIOPLATFORM_ATTR_RO(name) __ATTR(name, S_IRUGO, sdioplatform_##name##_show, NULL)
|
|
|
|
|
|
+
|
|
|
|
|
|
+static struct device_attribute sdioplatform_dev_attrs[] = {
|
|
|
|
|
|
+ SDIOPLATFORM_ATTR_RO(bus_id),
|
|
|
|
|
|
+ __ATTR_NULL
|
|
|
|
|
|
+};
|
|
|
|
|
|
+
|
|
|
|
|
|
+static struct bus_type sdioplatform_bus_type = {
|
|
|
|
|
|
+ .name = "sdioplatform",
|
|
|
|
|
|
+ .dev_attrs = sdioplatform_dev_attrs,
|
|
|
|
|
|
+ .match = sdioplatform_bus_match,
|
|
|
|
|
|
+ .hotplug = NULL,
|
|
|
|
|
|
+ .suspend = sdioplatform_bus_suspend,
|
|
|
|
|
|
+ .resume = sdioplatform_bus_resume,
|
|
|
|
|
|
+};
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* controller functions */
|
|
|
|
|
|
+static int sdioplatform_controllerdrv_probe(struct device *dev)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ struct sdioplatform_controller_driver *drv = driver_to_sdioplatform_controller_driver(dev->driver);
|
|
|
|
|
|
+ struct sdioplatform_controller *controller = device_to_sdioplatform_controller(dev);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return drv->probe(controller);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static int sdioplatform_controllerdrv_remove(struct device *dev)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ struct sdioplatform_controller_driver *drv = driver_to_sdioplatform_controller_driver(dev->driver);
|
|
|
|
|
|
+ struct sdioplatform_controller *controller = device_to_sdioplatform_controller(dev);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return drv->remove(controller);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * sdioplatform_register_controller_driver - register a controller driver
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+int sdioplatform_register_controller_driver(struct sdioplatform_controller_driver *drv)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ drv->drv.bus = &sdioplatform_bus_type;
|
|
|
|
|
|
+ drv->drv.probe = sdioplatform_controllerdrv_probe;
|
|
|
|
|
|
+ drv->drv.remove = sdioplatform_controllerdrv_remove;
|
|
|
|
|
|
+ return driver_register(&drv->drv);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * sdioplatform_unregister_controller_driver - unregister a controller driver
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+void sdioplatform_unregister_controller_driver(struct sdioplatform_driver *drv)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ driver_unregister(&drv->drv);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * sdioplatform_add_controller - register a controller device
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+int sdioplatform_add_controller(char *name, struct sdioplatform_controller *dev)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ if (!dev) {
|
|
|
|
|
|
+ return -EINVAL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ strncpy(dev->dev.bus_id, BUS_ID_SIZE, name);
|
|
|
|
|
|
+ return device_register(&dev->dev);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * sdioplatform_remove_controller - unregister a controller device
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+int sdioplatform_remove_controller(char *name, struct sdioplatform_controller *dev)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ if (!dev) {
|
|
|
|
|
|
+ return -EINVAL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return device_unregister(&dev->dev);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* peripheral functions */
|
|
|
|
|
|
+static int sdioplatform_drv_probe(struct device *dev)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ struct sdioplatform_driver *drv = driver_to_sdioplatform_driver(dev->driver);
|
|
|
|
|
|
+ struct sdioplatform_peripheral *peripheral = device_to_sdioplatform_peripheral(dev);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return drv->probe(peripheral);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static int sdioplatform_controllerdrv_remove(struct device *dev)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ struct sdioplatform_controller_driver *drv = driver_to_sdioplatform_controller_driver(dev->driver);
|
|
|
|
|
|
+ struct sdioplatform_controller *controller = device_to_sdioplatform_controller(dev);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ return drv->remove(controller);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * sdioplatform_register_driver - register a driver
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+int sdioplatform_register_driver(struct sdioplatform_driver *drv)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ drv->drv.bus = &sdioplatform_bus_type;
|
|
|
|
|
|
+ drv->drv.probe = sdioplatform_drv_probe;
|
|
|
|
|
|
+ drv->drv.remove = sdioplatform_drv_remove;
|
|
|
|
|
|
+ return driver_register(&drv->drv);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * sdioplatform_unregister_driver - unregister a driver
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+void sdioplatform_unregister_driver(struct sdioplatform_driver *drv)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ driver_unregister(&drv->drv);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * sdioplatform_add_peripheral - register a peripheral device
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+int sdioplatform_add_peripheral(char *name, struct sdioplatform_peripheral *dev)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ if (!dev) {
|
|
|
|
|
|
+ return -EINVAL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ strncpy(dev->dev.bus_id, BUS_ID_SIZE, name);
|
|
|
|
|
|
+ return device_register(&dev->dev);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * sdioplatform_remove_peripheral - unregister a peripheral device
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+int sdioplatform_remove_peripheral(char *name, struct sdioplatform_peripheral *dev)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ if (!dev) {
|
|
|
|
|
|
+ return -EINVAL;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return device_unregister(&dev->dev);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+static int sdioplatform_bus_match(struct device *dev, struct device_driver *drv)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ /* probes handle the matching */
|
|
|
|
|
|
+ return 1;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static int sdioplatform_bus_suspend(struct device *dev, pm_message_t state)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ struct sdioplatform_driver *drv = driver_to_sdioplatform_driver(dev->driver);
|
|
|
|
|
|
+ struct sdioplatform_peripheral *peripheral = device_to_sdioplatform_peripheral(dev);
|
|
|
|
|
|
+ int ret = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (peripheral->driver && drv->suspend) {
|
|
|
|
|
|
+ ret = drv->suspend(peripheral, state);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return ret;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+static int sdioplatform_bus_resume(struct device *dev)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ struct sdioplatform_driver *drv = driver_to_sdioplatform_driver(dev->driver);
|
|
|
|
|
|
+ struct sdioplatform_peripheral *peripheral = device_to_sdioplatform_peripheral(dev);
|
|
|
|
|
|
+ int ret = 0;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ if (peripheral->driver && drv->resume) {
|
|
|
|
|
|
+ ret = drv->resume(card);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return ret;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * module init
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static int __init sdio_platformdriver_init(void) {
|
|
|
|
|
|
+ int ret = bus_register(&sdioplatform_bus_type);
|
|
|
|
|
|
+ return ret;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * module cleanup
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static void __exit sdio_platformdriver_cleanup(void) {
|
|
|
|
|
|
+ REL_PRINT(SDDBG_TRACE, ("SDIO unloaded\n"));
|
|
|
|
|
|
+ _SDIO_BusDriverCleanup();
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+MODULE_LICENSE("GPL");
|
|
|
|
|
|
+MODULE_DESCRIPTION(DESCRIPTION);
|
|
|
|
|
|
+MODULE_AUTHOR(AUTHOR);
|
|
|
|
|
|
+
|
|
|
|
|
|
+module_init(sdio_platformdriver_init);
|
|
|
|
|
|
+module_exit(sdio_platformdriver_cleanup);
|
|
|
|
|
|
+EXPORT_SYMBOL(sdioplatform_register_controller_driver);
|
|
|
|
|
|
+EXPORT_SYMBOL(sdioplatform_unregister_controller_driver);
|
|
|
|
|
|
+EXPORT_SYMBOL(sdioplatform_add_controller);
|
|
|
|
|
|
+EXPORT_SYMBOL(sdioplatform_remove_controller);
|
|
|
|
|
|
+EXPORT_SYMBOL(sdioplatform_register_driver);
|
|
|
|
|
|
+EXPORT_SYMBOL(sdioplatform_unregister_driver);
|
|
|
|
|
|
+EXPORT_SYMBOL(sdioplatform_add_peripheral);
|
|
|
|
|
|
+EXPORT_SYMBOL(sdioplatform_remove_peripheral);
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
diff --git a/include/linux/sdio/_sdio_defs.h b/include/linux/sdio/_sdio_defs.h
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..a3f5542
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/include/linux/sdio/_sdio_defs.h
|
|
|
|
|
|
@@ -0,0 +1,638 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: _sdio_defs.h
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: SD/SDIO definitions
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#ifndef ___SDIO_DEFS_H___
|
|
|
|
|
|
+#define ___SDIO_DEFS_H___
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_INIT_BUS_CLOCK 100000 /* initialization clock in hz */
|
|
|
|
|
|
+#define SPI_INIT_BUS_CLOCK 100000 /* initialization clock in hz */
|
|
|
|
|
|
+#define SD_MAX_BUS_CLOCK 25000000 /* max clock speed in hz */
|
|
|
|
|
|
+#define SD_HS_MAX_BUS_CLOCK 50000000 /* SD high speed max clock speed in hz */
|
|
|
|
|
|
+#define SDIO_LOW_SPEED_MAX_BUS_CLOCK 400000 /* max low speed clock in hz */
|
|
|
|
|
|
+#define SDMMC_MIN_INIT_CLOCKS 80 /* minimun number of initialization clocks */
|
|
|
|
|
|
+#define SDIO_EMPC_CURRENT_THRESHOLD 300 /* SDIO 1.10 , EMPC (mA) threshold, we add some overhead */
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* commands */
|
|
|
|
|
|
+#define CMD0 0
|
|
|
|
|
|
+#define CMD1 1
|
|
|
|
|
|
+#define CMD2 2
|
|
|
|
|
|
+#define CMD3 3
|
|
|
|
|
|
+#define CMD4 4
|
|
|
|
|
|
+#define CMD5 5
|
|
|
|
|
|
+#define CMD6 6
|
|
|
|
|
|
+#define CMD7 7
|
|
|
|
|
|
+#define CMD9 9
|
|
|
|
|
|
+#define CMD10 10
|
|
|
|
|
|
+#define CMD12 12
|
|
|
|
|
|
+#define CMD13 13
|
|
|
|
|
|
+#define CMD15 15
|
|
|
|
|
|
+#define CMD16 16
|
|
|
|
|
|
+#define CMD17 17
|
|
|
|
|
|
+#define CMD18 18
|
|
|
|
|
|
+#define CMD24 24
|
|
|
|
|
|
+#define CMD25 25
|
|
|
|
|
|
+#define CMD27 27
|
|
|
|
|
|
+#define CMD28 28
|
|
|
|
|
|
+#define CMD29 29
|
|
|
|
|
|
+#define CMD30 30
|
|
|
|
|
|
+#define CMD32 32
|
|
|
|
|
|
+#define CMD33 33
|
|
|
|
|
|
+#define CMD38 38
|
|
|
|
|
|
+#define CMD42 42
|
|
|
|
|
|
+#define CMD52 52
|
|
|
|
|
|
+#define CMD53 53
|
|
|
|
|
|
+#define CMD55 55
|
|
|
|
|
|
+#define CMD56 56
|
|
|
|
|
|
+#define CMD58 58
|
|
|
|
|
|
+#define CMD59 59
|
|
|
|
|
|
+#define ACMD6 6
|
|
|
|
|
|
+#define ACMD13 13
|
|
|
|
|
|
+#define ACMD22 22
|
|
|
|
|
|
+#define ACMD23 23
|
|
|
|
|
|
+#define ACMD41 41
|
|
|
|
|
|
+#define ACMD42 42
|
|
|
|
|
|
+#define ACMD51 51
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_ACMD6_BUS_WIDTH_1_BIT 0x00
|
|
|
|
|
|
+#define SD_ACMD6_BUS_WIDTH_4_BIT 0x02
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_CMD59_CRC_OFF 0x00000000
|
|
|
|
|
|
+#define SD_CMD59_CRC_ON 0x00000001
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SD/SPI max response size */
|
|
|
|
|
|
+#define SD_MAX_CMD_RESPONSE_BYTES SD_R2_RESPONSE_BYTES
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_R1_RESPONSE_BYTES 6
|
|
|
|
|
|
+#define SD_R1B_RESPONSE_BYTES SD_R1_RESPONSE_BYTES
|
|
|
|
|
|
+#define SD_R1_GET_CMD(pR) ((pR)[5] & 0xC0))
|
|
|
|
|
|
+#define SD_R1_SET_CMD(pR,cmd) (pR)[5] = (cmd) & 0xC0
|
|
|
|
|
|
+#define SD_R1_GET_CARD_STATUS(pR) (((UINT32)((pR)[1])) | \
|
|
|
|
|
|
+ (((UINT32)((pR)[2])) << 8) | \
|
|
|
|
|
|
+ (((UINT32)((pR)[3])) << 16) | \
|
|
|
|
|
|
+ (((UINT32)((pR)[4])) << 24) )
|
|
|
|
|
|
+#define SD_R1_SET_CMD_STATUS(pR,status) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ (pR)[1] = (UINT8)(status); \
|
|
|
|
|
|
+ (pR)[2] = (UINT8)((status) >> 8); \
|
|
|
|
|
|
+ (pR)[3] = (UINT8)((status) >> 16); \
|
|
|
|
|
|
+ (pR)[4] = (UINT8)((status) >> 24); \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SD R1 card status bit masks */
|
|
|
|
|
|
+#define SD_CS_CMD_OUT_OF_RANGE ((UINT32)(1 << 31))
|
|
|
|
|
|
+#define SD_CS_ADDRESS_ERR (1 << 30)
|
|
|
|
|
|
+#define SD_CS_BLK_LEN_ERR (1 << 29)
|
|
|
|
|
|
+#define SD_CS_ERASE_SEQ_ERR (1 << 28)
|
|
|
|
|
|
+#define SD_CS_ERASE_PARAM_ERR (1 << 27)
|
|
|
|
|
|
+#define SD_CS_WP_ERR (1 << 26)
|
|
|
|
|
|
+#define SD_CS_CARD_LOCKED (1 << 25)
|
|
|
|
|
|
+#define SD_CS_LK_UNLK_FAILED (1 << 24)
|
|
|
|
|
|
+#define SD_CS_PREV_CMD_CRC_ERR (1 << 23)
|
|
|
|
|
|
+#define SD_CS_ILLEGAL_CMD_ERR (1 << 22)
|
|
|
|
|
|
+#define SD_CS_ECC_FAILED (1 << 21)
|
|
|
|
|
|
+#define SD_CS_CARD_INTERNAL_ERR (1 << 20)
|
|
|
|
|
|
+#define SD_CS_GENERAL_ERR (1 << 19)
|
|
|
|
|
|
+#define SD_CS_CSD_OVERWR_ERR (1 << 16)
|
|
|
|
|
|
+#define SD_CS_WP_ERASE_SKIP (1 << 15)
|
|
|
|
|
|
+#define SD_CS_ECC_DISABLED (1 << 14)
|
|
|
|
|
|
+#define SD_CS_ERASE_RESET (1 << 13)
|
|
|
|
|
|
+#define SD_CS_GET_STATE(status) (((status) >> 9) & 0x0f)
|
|
|
|
|
|
+#define SD_CS_SET_STATE(status, state) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ (status) &= ~(0x0F << 9); \
|
|
|
|
|
|
+ (status) |= (state) << 9 \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_CS_TRANSFER_ERRORS \
|
|
|
|
|
|
+ ( SD_CS_ADDRESS_ERR | \
|
|
|
|
|
|
+ SD_CS_BLK_LEN_ERR | \
|
|
|
|
|
|
+ SD_CS_ERASE_SEQ_ERR | \
|
|
|
|
|
|
+ SD_CS_ERASE_PARAM_ERR | \
|
|
|
|
|
|
+ SD_CS_WP_ERR | \
|
|
|
|
|
|
+ SD_CS_ECC_FAILED | \
|
|
|
|
|
|
+ SD_CS_CARD_INTERNAL_ERR | \
|
|
|
|
|
|
+ SD_CS_GENERAL_ERR )
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_CS_STATE_IDLE 0
|
|
|
|
|
|
+#define SD_CS_STATE_READY 1
|
|
|
|
|
|
+#define SD_CS_STATE_IDENT 2
|
|
|
|
|
|
+#define SD_CS_STATE_STBY 3
|
|
|
|
|
|
+#define SD_CS_STATE_TRANS 4
|
|
|
|
|
|
+#define SD_CS_STATE_DATA 5
|
|
|
|
|
|
+#define SD_CS_STATE_RCV 6
|
|
|
|
|
|
+#define SD_CS_STATE_PRG 7
|
|
|
|
|
|
+#define SD_CS_STATE_DIS 8
|
|
|
|
|
|
+#define SD_CS_READY_FOR_DATA (1 << 8)
|
|
|
|
|
|
+#define SD_CS_APP_CMD (1 << 5)
|
|
|
|
|
|
+#define SD_CS_AKE_SEQ_ERR (1 << 3)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SD R2 response */
|
|
|
|
|
|
+#define SD_R2_RESPONSE_BYTES 17
|
|
|
|
|
|
+#define MAX_CSD_CID_BYTES 16
|
|
|
|
|
|
+#define SD_R2_SET_STUFF_BITS(pR) (pR)[16] = 0x3F
|
|
|
|
|
|
+#define GET_SD_CSD_TRANS_SPEED(pR) (pR)[12]
|
|
|
|
|
|
+#define GET_SD_CID_MANFID(pR) (pR)[15]
|
|
|
|
|
|
+#define GET_SD_CID_PN_1(pR) (pR)[12]
|
|
|
|
|
|
+#define GET_SD_CID_PN_2(pR) (pR)[11]
|
|
|
|
|
|
+#define GET_SD_CID_PN_3(pR) (pR)[10]
|
|
|
|
|
|
+#define GET_SD_CID_PN_4(pR) (pR)[9]
|
|
|
|
|
|
+#define GET_SD_CID_PN_5(pR) (pR)[8]
|
|
|
|
|
|
+#define GET_SD_CID_PN_6(pR) (pR)[7]
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define GET_SD_CID_OEMID(pR) ((((UINT16)(pR)[14]) << 8 )| (UINT16)((pR)[13]))
|
|
|
|
|
|
+#define SDMMC_OCR_VOLTAGE_MASK 0x7FFFFFFF
|
|
|
|
|
|
+/* SD R3 response */
|
|
|
|
|
|
+#define SD_R3_RESPONSE_BYTES 6
|
|
|
|
|
|
+#define SD_R3_GET_OCR(pR) ((((UINT32)((pR)[1])) | \
|
|
|
|
|
|
+ (((UINT32)((pR)[2])) << 8) | \
|
|
|
|
|
|
+ (((UINT32)((pR)[3])) << 16) | \
|
|
|
|
|
|
+ (((UINT32)((pR)[4])) << 24)) & SDMMC_OCR_VOLTAGE_MASK)
|
|
|
|
|
|
+#define SD_R3_IS_CARD_READY(pR) (((pR)[4] & 0x80) == 0x80)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* OCR bit definitions */
|
|
|
|
|
|
+#define SD_OCR_CARD_PWR_UP_STATUS ((UINT32)(1 << 31))
|
|
|
|
|
|
+#define SD_OCR_3_5_TO_3_6_VDD (1 << 23)
|
|
|
|
|
|
+#define SD_OCR_3_4_TO_3_5_VDD (1 << 22)
|
|
|
|
|
|
+#define SD_OCR_3_3_TO_3_4_VDD (1 << 21)
|
|
|
|
|
|
+#define SD_OCR_3_2_TO_3_3_VDD (1 << 20)
|
|
|
|
|
|
+#define SD_OCR_3_1_TO_3_2_VDD (1 << 19)
|
|
|
|
|
|
+#define SD_OCR_3_0_TO_3_1_VDD (1 << 18)
|
|
|
|
|
|
+#define SD_OCR_2_9_TO_3_0_VDD (1 << 17)
|
|
|
|
|
|
+#define SD_OCR_2_8_TO_2_9_VDD (1 << 16)
|
|
|
|
|
|
+#define SD_OCR_2_7_TO_2_8_VDD (1 << 15)
|
|
|
|
|
|
+#define SD_OCR_2_6_TO_2_7_VDD (1 << 14)
|
|
|
|
|
|
+#define SD_OCR_2_5_TO_2_6_VDD (1 << 13)
|
|
|
|
|
|
+#define SD_OCR_2_4_TO_2_5_VDD (1 << 12)
|
|
|
|
|
|
+#define SD_OCR_2_3_TO_2_4_VDD (1 << 11)
|
|
|
|
|
|
+#define SD_OCR_2_2_TO_2_3_VDD (1 << 10)
|
|
|
|
|
|
+#define SD_OCR_2_1_TO_2_2_VDD (1 << 9)
|
|
|
|
|
|
+#define SD_OCR_2_0_TO_2_1_VDD (1 << 8)
|
|
|
|
|
|
+#define SD_OCR_1_9_TO_2_0_VDD (1 << 7)
|
|
|
|
|
|
+#define SD_OCR_1_8_TO_1_9_VDD (1 << 6)
|
|
|
|
|
|
+#define SD_OCR_1_7_TO_1_8_VDD (1 << 5)
|
|
|
|
|
|
+#define SD_OCR_1_6_TO_1_7_VDD (1 << 4)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SD Status data block */
|
|
|
|
|
|
+#define SD_STATUS_DATA_BYTES 64
|
|
|
|
|
|
+#define SDS_GET_DATA_WIDTH(buffer) ((buffer)[0] & 0xC0)
|
|
|
|
|
|
+#define SDS_BUS_1_BIT 0x00
|
|
|
|
|
|
+#define SDS_BUS_4_BIT 0x80
|
|
|
|
|
|
+#define SDS_GET_SECURE_MODE(buffer) ((buffer)[0] & 0x20)
|
|
|
|
|
|
+#define SDS_CARD_SECURE_MODE 0x20
|
|
|
|
|
|
+#define SDS_GET_CARD_TYPE(buffer) ((buffer)[60] & 0x0F)
|
|
|
|
|
|
+#define SDS_SD_CARD_RW 0x00
|
|
|
|
|
|
+#define SDS_SD_CARD_ROM 0x01
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SD R6 response */
|
|
|
|
|
|
+#define SD_R6_RESPONSE_BYTES 6
|
|
|
|
|
|
+#define SD_R6_GET_RCA(pR) ((UINT16)((pR)[3]) | (((UINT16)((pR)[4])) << 8))
|
|
|
|
|
|
+#define SD_R6_GET_CS(pR) ((UINT16)((pR)[1]) | (((UINT16)((pR)[2])) << 8))
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SD Configuration Register (SCR) */
|
|
|
|
|
|
+#define SD_SCR_BYTES 8
|
|
|
|
|
|
+#define SCR_REV_1_0 0x00
|
|
|
|
|
|
+#define SCR_SD_SPEC_1_00 0x00
|
|
|
|
|
|
+#define SCR_SD_SPEC_1_10 0x01
|
|
|
|
|
|
+#define SCR_BUS_SUPPORTS_1_BIT 0x01
|
|
|
|
|
|
+#define SCR_BUS_SUPPORTS_4_BIT 0x04
|
|
|
|
|
|
+#define SCR_SD_SECURITY_MASK 0x70
|
|
|
|
|
|
+#define SCR_SD_NO_SECURITY 0x00
|
|
|
|
|
|
+#define SCR_SD_SECURITY_1_0 0x10
|
|
|
|
|
|
+#define SCR_SD_SECURITY_2_0 0x20
|
|
|
|
|
|
+#define SCR_DATA_STATUS_1_AFTER_ERASE 0x80
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define GET_SD_SCR_STRUCT_VER(pB) ((pB)[7] >> 4)
|
|
|
|
|
|
+#define GET_SD_SCR_SDSPEC_VER(pB) ((pB)[7] & 0x0F)
|
|
|
|
|
|
+#define GET_SD_SCR_BUSWIDTHS(pB) ((pB)[6] & 0x0F)
|
|
|
|
|
|
+#define GET_SD_SCR_BUSWIDTHS_FLAGS(pB) (pB)[6]
|
|
|
|
|
|
+#define GET_SD_SCR_SECURITY(pB) (((pB)[6] >> 4) & 0x07)
|
|
|
|
|
|
+#define GET_SD_SCR_DATA_STAT_AFTER_ERASE(pB) (((pB)[6] >> 7) & 0x01)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SDIO R4 Response */
|
|
|
|
|
|
+#define SD_SDIO_R4_RESPONSE_BYTES 6
|
|
|
|
|
|
+#define SD_SDIO_R4_GET_OCR(pR) ((UINT32)((pR)[1]) | \
|
|
|
|
|
|
+ (((UINT32)(pR)[2]) << 8) | \
|
|
|
|
|
|
+ (((UINT32)(pR)[3]) << 16))
|
|
|
|
|
|
+#define SD_SDIO_R4_IS_MEMORY_PRESENT(pR) (((pR)[4] & 0x08) == 0x08)
|
|
|
|
|
|
+#define SD_SDIO_R4_GET_IO_FUNC_COUNT(pR) (((pR)[4] >> 4) & 0x07)
|
|
|
|
|
|
+#define SD_SDIO_R4_IS_CARD_READY(pR) (((pR)[4] & 0x80) == 0x80)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SDIO R5 response */
|
|
|
|
|
|
+#define SD_SDIO_R5_RESPONSE_BYTES 6
|
|
|
|
|
|
+#define SD_SDIO_R5_READ_DATA_OFFSET 1
|
|
|
|
|
|
+#define SD_R5_GET_READ_DATA(pR) (pR)[SD_SDIO_R5_READ_DATA_OFFSET]
|
|
|
|
|
|
+#define SD_R5_RESP_FLAGS_OFFSET 2
|
|
|
|
|
|
+#define SD_R5_GET_RESP_FLAGS(pR) (pR)[SD_R5_RESP_FLAGS_OFFSET]
|
|
|
|
|
|
+#define SD_R5_SET_CMD(pR,cmd) (pR)[5] = (cmd) & 0xC0
|
|
|
|
|
|
+#define SD_R5_RESP_CMD_ERR (1 << 7) /* for previous cmd */
|
|
|
|
|
|
+#define SD_R5_ILLEGAL_CMD (1 << 6)
|
|
|
|
|
|
+#define SD_R5_GENERAL_ERR (1 << 3)
|
|
|
|
|
|
+#define SD_R5_INVALID_FUNC (1 << 1)
|
|
|
|
|
|
+#define SD_R5_ARG_RANGE_ERR (1 << 0)
|
|
|
|
|
|
+#define SD_R5_CURRENT_CMD_ERRORS (SD_R5_ILLEGAL_CMD | SD_R5_GENERAL_ERR \
|
|
|
|
|
|
+ | SD_R5_INVALID_FUNC | SD_R5_ARG_RANGE_ERR)
|
|
|
|
|
|
+#define SD_R5_ERRORS (SD_R5_CURRENT_CMD_ERRORS)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_R5_GET_IO_STATE(pR) (((pR)[2] >> 4) & 0x03)
|
|
|
|
|
|
+#define SD_R5_STATE_DIS 0x00
|
|
|
|
|
|
+#define SD_R5_STATE_CMD 0x01
|
|
|
|
|
|
+#define SD_R5_STATE_TRN 0x02
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SDIO Modified R6 Response */
|
|
|
|
|
|
+#define SD_SDIO_R6_RESPONSE_BYTES 6
|
|
|
|
|
|
+#define SD_SDIO_R6_GET_RCA(pR) ((UINT16)((pR)[3]) | ((UINT16)((pR)[4]) << 8))
|
|
|
|
|
|
+#define SD_SDIO_R6_GET_CSTAT(pR)((UINT16)((pR)[1]) | ((UINT16)((pR)[2]) << 8))
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SPI mode R1 response */
|
|
|
|
|
|
+#define SPI_R1_RESPONSE_BYTES 1
|
|
|
|
|
|
+#define GET_SPI_R1_RESP_TOKEN(pR) (pR)[0]
|
|
|
|
|
|
+#define SPI_CS_STATE_IDLE 0x01
|
|
|
|
|
|
+#define SPI_CS_ERASE_RESET (1 << 1)
|
|
|
|
|
|
+#define SPI_CS_ILLEGAL_CMD (1 << 2)
|
|
|
|
|
|
+#define SPI_CS_CMD_CRC_ERR (1 << 3)
|
|
|
|
|
|
+#define SPI_CS_ERASE_SEQ_ERR (1 << 4)
|
|
|
|
|
|
+#define SPI_CS_ADDRESS_ERR (1 << 5)
|
|
|
|
|
|
+#define SPI_CS_PARAM_ERR (1 << 6)
|
|
|
|
|
|
+#define SPI_CS_ERR_MASK 0x7c
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SPI mode R2 response */
|
|
|
|
|
|
+#define SPI_R2_RESPONSE_BYTES 2
|
|
|
|
|
|
+#define GET_SPI_R2_RESP_TOKEN(pR) (pR)[1]
|
|
|
|
|
|
+#define GET_SPI_R2_STATUS_TOKEN(pR) (pR)[0]
|
|
|
|
|
|
+/* the first response byte is defined above */
|
|
|
|
|
|
+/* the second response byte is defined below */
|
|
|
|
|
|
+#define SPI_CS_CARD_IS_LOCKED (1 << 0)
|
|
|
|
|
|
+#define SPI_CS_LOCK_UNLOCK_FAILED (1 << 1)
|
|
|
|
|
|
+#define SPI_CS_ERROR (1 << 2)
|
|
|
|
|
|
+#define SPI_CS_INTERNAL_ERROR (1 << 3)
|
|
|
|
|
|
+#define SPI_CS_ECC_FAILED (1 << 4)
|
|
|
|
|
|
+#define SPI_CS_WP_VIOLATION (1 << 5)
|
|
|
|
|
|
+#define SPI_CS_ERASE_PARAM_ERR (1 << 6)
|
|
|
|
|
|
+#define SPI_CS_OUT_OF_RANGE (1 << 7)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SPI mode R3 response */
|
|
|
|
|
|
+#define SPI_R3_RESPONSE_BYTES 5
|
|
|
|
|
|
+#define SPI_R3_GET_OCR(pR) ((((UINT32)((pR)[0])) | \
|
|
|
|
|
|
+ (((UINT32)((pR)[1])) << 8) | \
|
|
|
|
|
|
+ (((UINT32)((pR)[2])) << 16) | \
|
|
|
|
|
|
+ (((UINT32)((pR)[3])) << 24)) & SDMMC_OCR_VOLTAGE_MASK)
|
|
|
|
|
|
+#define SPI_R3_IS_CARD_READY(pR) (((pR)[3] & 0x80) == 0x80)
|
|
|
|
|
|
+#define GET_SPI_R3_RESP_TOKEN(pR) (pR)[4]
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SPI mode SDIO R4 response */
|
|
|
|
|
|
+#define SPI_SDIO_R4_RESPONSE_BYTES 5
|
|
|
|
|
|
+#define SPI_SDIO_R4_GET_OCR(pR) ((UINT32)((pR)[0]) | \
|
|
|
|
|
|
+ (((UINT32)(pR)[1]) << 8) | \
|
|
|
|
|
|
+ (((UINT32)(pR)[2]) << 16))
|
|
|
|
|
|
+#define SPI_SDIO_R4_IS_MEMORY_PRESENT(pR) (((pR)[3] & 0x08) == 0x08)
|
|
|
|
|
|
+#define SPI_SDIO_R4_GET_IO_FUNC_COUNT(pR) (((pR)[3] >> 4) & 0x07)
|
|
|
|
|
|
+#define SPI_SDIO_R4_IS_CARD_READY(pR) (((pR)[3] & 0x80) == 0x80)
|
|
|
|
|
|
+#define GET_SPI_SDIO_R4_RESP_TOKEN(pR) (pR)[4]
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SPI Mode SDIO R5 response */
|
|
|
|
|
|
+#define SPI_SDIO_R5_RESPONSE_BYTES 2
|
|
|
|
|
|
+#define GET_SPI_SDIO_R5_RESP_TOKEN(pR) (pR)[1]
|
|
|
|
|
|
+#define GET_SPI_SDIO_R5_RESPONSE_RDATA(pR) (pR)[0]
|
|
|
|
|
|
+#define SPI_R5_IDLE_STATE 0x01
|
|
|
|
|
|
+#define SPI_R5_ILLEGAL_CMD (1 << 2)
|
|
|
|
|
|
+#define SPI_R5_CMD_CRC (1 << 3)
|
|
|
|
|
|
+#define SPI_R5_FUNC_ERR (1 << 4)
|
|
|
|
|
|
+#define SPI_R5_PARAM_ERR (1 << 6)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SDIO COMMAND 52 Definitions */
|
|
|
|
|
|
+#define CMD52_READ 0
|
|
|
|
|
|
+#define CMD52_WRITE 1
|
|
|
|
|
|
+#define CMD52_READ_AFTER_WRITE 1
|
|
|
|
|
|
+#define CMD52_NORMAL_WRITE 0
|
|
|
|
|
|
+#define SDIO_SET_CMD52_ARG(arg,rw,func,raw,address,writedata) \
|
|
|
|
|
|
+ (arg) = (((rw) & 1) << 31) | \
|
|
|
|
|
|
+ (((func) & 0x7) << 28) | \
|
|
|
|
|
|
+ (((raw) & 1) << 27) | \
|
|
|
|
|
|
+ (1 << 26) | \
|
|
|
|
|
|
+ (((address) & 0x1FFFF) << 9) | \
|
|
|
|
|
|
+ (1 << 8) | \
|
|
|
|
|
|
+ ((writedata) & 0xFF)
|
|
|
|
|
|
+#define SDIO_SET_CMD52_READ_ARG(arg,func,address) \
|
|
|
|
|
|
+ SDIO_SET_CMD52_ARG(arg,CMD52_READ,(func),0,address,0x00)
|
|
|
|
|
|
+#define SDIO_SET_CMD52_WRITE_ARG(arg,func,address,value) \
|
|
|
|
|
|
+ SDIO_SET_CMD52_ARG(arg,CMD52_WRITE,(func),CMD52_NORMAL_WRITE,address,value)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SDIO COMMAND 53 Definitions */
|
|
|
|
|
|
+#define CMD53_READ 0
|
|
|
|
|
|
+#define CMD53_WRITE 1
|
|
|
|
|
|
+#define CMD53_BLOCK_BASIS 1
|
|
|
|
|
|
+#define CMD53_BYTE_BASIS 0
|
|
|
|
|
|
+#define CMD53_FIXED_ADDRESS 0
|
|
|
|
|
|
+#define CMD53_INCR_ADDRESS 1
|
|
|
|
|
|
+#define SDIO_SET_CMD53_ARG(arg,rw,func,mode,opcode,address,bytes_blocks) \
|
|
|
|
|
|
+ (arg) = (((rw) & 1) << 31) | \
|
|
|
|
|
|
+ (((func) & 0x7) << 28) | \
|
|
|
|
|
|
+ (((mode) & 1) << 27) | \
|
|
|
|
|
|
+ (((opcode) & 1) << 26) | \
|
|
|
|
|
|
+ (((address) & 0x1FFFF) << 9) | \
|
|
|
|
|
|
+ ((bytes_blocks) & 0x1FF)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDIO_MAX_LENGTH_BYTE_BASIS 512
|
|
|
|
|
|
+#define SDIO_MAX_BLOCKS_BLOCK_BASIS 511
|
|
|
|
|
|
+#define SDIO_MAX_BYTES_PER_BLOCK 2048
|
|
|
|
|
|
+#define SDIO_COMMON_AREA_FUNCTION_NUMBER 0
|
|
|
|
|
|
+#define SDIO_FIRST_FUNCTION_NUMBER 1
|
|
|
|
|
|
+#define SDIO_LAST_FUNCTION_NUMBER 7
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define CMD53_CONVERT_BYTE_BASIS_BLK_LENGTH_PARAM(b) (((b) < SDIO_MAX_LENGTH_BYTE_BASIS) ? (b) : 0)
|
|
|
|
|
|
+#define CMD53_CONVERT_BLOCK_BASIS_BLK_COUNT_PARAM(b) (((b) <= SDIO_MAX_BLOCKS_BLOCK_BASIS) ? (b) : 0)
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SDIO COMMON Registers */
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* revision register */
|
|
|
|
|
|
+#define CCCR_SDIO_REVISION_REG 0x00
|
|
|
|
|
|
+#define CCCR_REV_MASK 0x0F
|
|
|
|
|
|
+#define CCCR_REV_1_0 0x00
|
|
|
|
|
|
+#define CCCR_REV_1_1 0x01
|
|
|
|
|
|
+#define SDIO_REV_MASK 0xF0
|
|
|
|
|
|
+#define SDIO_REV_1_00 0x00
|
|
|
|
|
|
+#define SDIO_REV_1_10 0x10
|
|
|
|
|
|
+#define SDIO_REV_1_20 0x20
|
|
|
|
|
|
+/* SD physical spec revision */
|
|
|
|
|
|
+#define SD_SPEC_REVISION_REG 0x01
|
|
|
|
|
|
+#define SD_REV_MASK 0x0F
|
|
|
|
|
|
+#define SD_REV_1_01 0x00
|
|
|
|
|
|
+#define SD_REV_1_10 0x01
|
|
|
|
|
|
+/* I/O Enable */
|
|
|
|
|
|
+#define SDIO_ENABLE_REG 0x02
|
|
|
|
|
|
+/* I/O Ready */
|
|
|
|
|
|
+#define SDIO_READY_REG 0x03
|
|
|
|
|
|
+/* Interrupt Enable */
|
|
|
|
|
|
+#define SDIO_INT_ENABLE_REG 0x04
|
|
|
|
|
|
+#define SDIO_INT_MASTER_ENABLE 0x01
|
|
|
|
|
|
+#define SDIO_INT_ALL_ENABLE 0xFE
|
|
|
|
|
|
+/* Interrupt Pending */
|
|
|
|
|
|
+#define SDIO_INT_PENDING_REG 0x05
|
|
|
|
|
|
+#define SDIO_INT_PEND_MASK 0xFE
|
|
|
|
|
|
+/* I/O Abort */
|
|
|
|
|
|
+#define SDIO_IO_ABORT_REG 0x06
|
|
|
|
|
|
+#define SDIO_IO_RESET (1 << 3)
|
|
|
|
|
|
+/* Bus Interface */
|
|
|
|
|
|
+#define SDIO_BUS_IF_REG 0x07
|
|
|
|
|
|
+#define CARD_DETECT_DISABLE 0x80
|
|
|
|
|
|
+#define SDIO_BUS_WIDTH_1_BIT 0x00
|
|
|
|
|
|
+#define SDIO_BUS_WIDTH_4_BIT 0x02
|
|
|
|
|
|
+/* Card Capabilities */
|
|
|
|
|
|
+#define SDIO_CARD_CAPS_REG 0x08
|
|
|
|
|
|
+#define SDIO_CAPS_CMD52_WHILE_DATA 0x01 /* card can issue CMD52 while data transfer */
|
|
|
|
|
|
+#define SDIO_CAPS_MULTI_BLOCK 0x02 /* card supports multi-block data transfers */
|
|
|
|
|
|
+#define SDIO_CAPS_READ_WAIT 0x04 /* card supports read-wait protocol */
|
|
|
|
|
|
+#define SDIO_CAPS_SUSPEND_RESUME 0x08 /* card supports I/O function suspend/resume */
|
|
|
|
|
|
+#define SDIO_CAPS_INT_MULTI_BLK 0x10 /* interrupts between multi-block data capable */
|
|
|
|
|
|
+#define SDIO_CAPS_ENB_INT_MULTI_BLK 0x20 /* enable ints between muli-block data */
|
|
|
|
|
|
+#define SDIO_CAPS_LOW_SPEED 0x40 /* low speed card */
|
|
|
|
|
|
+#define SDIO_CAPS_4BIT_LS 0x80 /* 4 bit low speed card */
|
|
|
|
|
|
+/* Common CIS pointer */
|
|
|
|
|
|
+#define SDIO_CMN_CIS_PTR_LOW_REG 0x09
|
|
|
|
|
|
+#define SDIO_CMN_CIS_PTR_MID_REG 0x0a
|
|
|
|
|
|
+#define SDIO_CMN_CIS_PTR_HI_REG 0x0b
|
|
|
|
|
|
+/* Bus suspend */
|
|
|
|
|
|
+#define SDIO_BUS_SUSPEND_REG 0x0c
|
|
|
|
|
|
+#define SDIO_FUNC_SUSPEND_STATUS_MASK 0x01 /* selected function is suspended */
|
|
|
|
|
|
+#define SDIO_SUSPEND_FUNCTION 0x02 /* suspend the current selected function */
|
|
|
|
|
|
+/* Function select (for bus suspension) */
|
|
|
|
|
|
+#define SDIO_FUNCTION_SELECT_REG 0x0d
|
|
|
|
|
|
+#define SDIO_SUSPEND_FUNCTION_0 0x00
|
|
|
|
|
|
+#define SDIO_SUSPEND_MEMORY_FUNC_MASK 0x08
|
|
|
|
|
|
+/* Function Execution */
|
|
|
|
|
|
+#define SDIO_FUNCTION_EXEC_REG 0x0e
|
|
|
|
|
|
+#define SDIO_MEMORY_FUNC_EXEC_MASK 0x01
|
|
|
|
|
|
+/* Function Ready */
|
|
|
|
|
|
+#define SDIO_FUNCTION_READY_REG 0x0f
|
|
|
|
|
|
+#define SDIO_MEMORY_FUNC_BUSY_MASK 0x01
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* power control 1.10 only */
|
|
|
|
|
|
+#define SDIO_POWER_CONTROL_REG 0x12
|
|
|
|
|
|
+#define SDIO_POWER_CONTROL_SMPC 0x01
|
|
|
|
|
|
+#define SDIO_POWER_CONTROL_EMPC 0x02
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* high speed control , 1.20 only */
|
|
|
|
|
|
+#define SDIO_HS_CONTROL_REG 0x13
|
|
|
|
|
|
+#define SDIO_HS_CONTROL_SHS 0x01
|
|
|
|
|
|
+#define SDIO_HS_CONTROL_EHS 0x02
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* Function Base Registers */
|
|
|
|
|
|
+#define xFUNCTION_FBR_OFFSET(funcNo) (0x100*(funcNo))
|
|
|
|
|
|
+/* offset calculation that does not use multiplication */
|
|
|
|
|
|
+static INLINE UINT32 CalculateFBROffset(UCHAR FuncNo) {
|
|
|
|
|
|
+ UCHAR i = FuncNo;
|
|
|
|
|
|
+ UINT32 offset = 0;
|
|
|
|
|
|
+ while (i) {
|
|
|
|
|
|
+ offset += 0x100;
|
|
|
|
|
|
+ i--;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return offset;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/* Function info */
|
|
|
|
|
|
+#define FBR_FUNC_INFO_REG_OFFSET(fbr) ((fbr) + 0x00)
|
|
|
|
|
|
+#define FUNC_INFO_SUPPORTS_CSA_MASK 0x40
|
|
|
|
|
|
+#define FUNC_INFO_ENABLE_CSA 0x80
|
|
|
|
|
|
+#define FUNC_INFO_DEVICE_CODE_MASK 0x0F
|
|
|
|
|
|
+#define FUNC_INFO_DEVICE_CODE_LAST 0x0F
|
|
|
|
|
|
+#define FBR_FUNC_EXT_DEVICE_CODE_OFFSET(fbr) ((fbr) + 0x01)
|
|
|
|
|
|
+/* Function Power selection */
|
|
|
|
|
|
+#define FBR_FUNC_POWER_SELECT_OFFSET(fbr) ((fbr) + 0x02)
|
|
|
|
|
|
+#define FUNC_POWER_SELECT_SPS 0x01
|
|
|
|
|
|
+#define FUNC_POWER_SELECT_EPS 0x02
|
|
|
|
|
|
+/* Function CIS ptr */
|
|
|
|
|
|
+#define FBR_FUNC_CIS_LOW_OFFSET(fbr) ((fbr) + 0x09)
|
|
|
|
|
|
+#define FBR_FUNC_CIS_MID_OFFSET(fbr) ((fbr) + 0x0a)
|
|
|
|
|
|
+#define FBR_FUNC_CIS_HI_OFFSET(fbr) ((fbr) + 0x0b)
|
|
|
|
|
|
+/* Function CSA ptr */
|
|
|
|
|
|
+#define FBR_FUNC_CSA_LOW_OFFSET(fbr) ((fbr) + 0x0c)
|
|
|
|
|
|
+#define FBR_FUNC_CSA_MID_OFFSET(fbr) ((fbr) + 0x0d)
|
|
|
|
|
|
+#define FBR_FUNC_CSA_HI_OFFSET(fbr) ((fbr) + 0x0e)
|
|
|
|
|
|
+/* Function CSA data window */
|
|
|
|
|
|
+#define FBR_FUNC_CSA_DATA_OFFSET(fbr) ((fbr) + 0x0f)
|
|
|
|
|
|
+/* Function Block Size Control */
|
|
|
|
|
|
+#define FBR_FUNC_BLK_SIZE_LOW_OFFSET(fbr) ((fbr) + 0x10)
|
|
|
|
|
|
+#define FBR_FUNC_BLK_SIZE_HI_OFFSET(fbr) ((fbr) + 0x11)
|
|
|
|
|
|
+#define SDIO_CIS_AREA_BEGIN 0x00001000
|
|
|
|
|
|
+#define SDIO_CIS_AREA_END 0x00017fff
|
|
|
|
|
|
+/* Tuple definitions */
|
|
|
|
|
|
+#define CISTPL_NULL 0x00
|
|
|
|
|
|
+#define CISTPL_CHECKSUM 0x10
|
|
|
|
|
|
+#define CISTPL_VERS_1 0x15
|
|
|
|
|
|
+#define CISTPL_ALTSTR 0x16
|
|
|
|
|
|
+#define CISTPL_MANFID 0x20
|
|
|
|
|
|
+#define CISTPL_FUNCID 0x21
|
|
|
|
|
|
+#define CISTPL_FUNCE 0x22
|
|
|
|
|
|
+#define CISTPL_VENDOR 0x91
|
|
|
|
|
|
+#define CISTPL_END 0xff
|
|
|
|
|
|
+#define CISTPL_LINK_END 0xff
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* these structures must be packed */
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* Manufacturer ID tuple */
|
|
|
|
|
|
+struct SDIO_MANFID_TPL {
|
|
|
|
|
|
+ UINT16 ManufacturerCode; /* jedec code */
|
|
|
|
|
|
+ UINT16 ManufacturerInfo; /* manufacturer specific code */
|
|
|
|
|
|
+}CT_PACK_STRUCT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* Function ID Tuple */
|
|
|
|
|
|
+struct SDIO_FUNC_ID_TPL {
|
|
|
|
|
|
+ UINT8 DeviceCode; /* device code */
|
|
|
|
|
|
+ UINT8 InitMask; /* system initialization mask (not used) */
|
|
|
|
|
|
+}CT_PACK_STRUCT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* Extended Function Tuple (Common) */
|
|
|
|
|
|
+struct SDIO_FUNC_EXT_COMMON_TPL {
|
|
|
|
|
|
+ UINT8 Type; /* type */
|
|
|
|
|
|
+ UINT16 Func0_MaxBlockSize; /* max function 0 block transfer size */
|
|
|
|
|
|
+ UINT8 MaxTransSpeed; /* max transfer speed (encoded) */
|
|
|
|
|
|
+#define TRANSFER_UNIT_MULTIPIER_MASK 0x07
|
|
|
|
|
|
+#define TIME_VALUE_MASK 0x78
|
|
|
|
|
|
+#define TIME_VALUE_SHIFT 3
|
|
|
|
|
|
+}CT_PACK_STRUCT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* Extended Function Tuple (Per Function) */
|
|
|
|
|
|
+struct SDIO_FUNC_EXT_FUNCTION_TPL {
|
|
|
|
|
|
+ UINT8 Type; /* type */
|
|
|
|
|
|
+#define SDIO_FUNC_INFO_WAKEUP_SUPPORT 0x01
|
|
|
|
|
|
+ UINT8 FunctionInfo; /* function info */
|
|
|
|
|
|
+ UINT8 SDIORev; /* revision */
|
|
|
|
|
|
+ UINT32 CardPSN; /* product serial number */
|
|
|
|
|
|
+ UINT32 CSASize; /* CSA size */
|
|
|
|
|
|
+ UINT8 CSAProperties; /* CSA properties */
|
|
|
|
|
|
+ UINT16 MaxBlockSize; /* max block size for block transfers */
|
|
|
|
|
|
+ UINT32 FunctionOCR; /* optimal function OCR */
|
|
|
|
|
|
+ UINT8 OpMinPwr; /* operational min power */
|
|
|
|
|
|
+ UINT8 OpAvgPwr; /* operational average power */
|
|
|
|
|
|
+ UINT8 OpMaxPwr; /* operation maximum power */
|
|
|
|
|
|
+ UINT8 SbMinPwr; /* standby minimum power */
|
|
|
|
|
|
+ UINT8 SbAvgPwr; /* standby average power */
|
|
|
|
|
|
+ UINT8 SbMaxPwr; /* standby maximum power */
|
|
|
|
|
|
+ UINT16 MinBandWidth; /* minimum bus bandwidth */
|
|
|
|
|
|
+ UINT16 OptBandWidth; /* optimalbus bandwitdh */
|
|
|
|
|
|
+}CT_PACK_STRUCT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+struct SDIO_FUNC_EXT_FUNCTION_TPL_1_1 {
|
|
|
|
|
|
+ struct SDIO_FUNC_EXT_FUNCTION_TPL CommonInfo; /* from 1.0*/
|
|
|
|
|
|
+ UINT16 EnableTimeOut; /* timeout for enable */
|
|
|
|
|
|
+ UINT16 OperPwrMaxPwr;
|
|
|
|
|
|
+ UINT16 OperPwrAvgPwr;
|
|
|
|
|
|
+ UINT16 HiPwrMaxPwr;
|
|
|
|
|
|
+ UINT16 HiPwrAvgPwr;
|
|
|
|
|
|
+ UINT16 LowPwrMaxPwr;
|
|
|
|
|
|
+ UINT16 LowPwrAvgPwr;
|
|
|
|
|
|
+}CT_PACK_STRUCT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE SDIO_STATUS ConvertCMD52ResponseToSDIOStatus(UINT8 CMD52ResponseFlags) {
|
|
|
|
|
|
+ if (!(CMD52ResponseFlags & SD_R5_ERRORS)) {
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (CMD52ResponseFlags & SD_R5_ILLEGAL_CMD) {
|
|
|
|
|
|
+ return SDIO_STATUS_DATA_STATE_INVALID;
|
|
|
|
|
|
+ } else if (CMD52ResponseFlags & SD_R5_INVALID_FUNC) {
|
|
|
|
|
|
+ return SDIO_STATUS_INVALID_FUNC;
|
|
|
|
|
|
+ } else if (CMD52ResponseFlags & SD_R5_ARG_RANGE_ERR) {
|
|
|
|
|
|
+ return SDIO_STATUS_FUNC_ARG_ERROR;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ return SDIO_STATUS_DATA_ERROR_UNKNOWN;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* CMD6 mode switch definitions */
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_SWITCH_FUNC_CHECK 0
|
|
|
|
|
|
+#define SD_SWITCH_FUNC_SET ((UINT32)(1 << 31))
|
|
|
|
|
|
+#define SD_FUNC_NO_SELECT_MASK 0x00FFFFFF
|
|
|
|
|
|
+#define SD_SWITCH_GRP_1 0
|
|
|
|
|
|
+#define SD_SWITCH_GRP_2 1
|
|
|
|
|
|
+#define SD_SWITCH_GRP_3 2
|
|
|
|
|
|
+#define SD_SWITCH_GRP_4 3
|
|
|
|
|
|
+#define SD_SWITCH_GRP_5 4
|
|
|
|
|
|
+#define SD_SWITCH_GRP_6 5
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_SWITCH_HIGH_SPEED_GROUP SD_SWITCH_GRP_1
|
|
|
|
|
|
+#define SD_SWITCH_HIGH_SPEED_FUNC_NO 1
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_SWITCH_MAKE_SHIFT(grp) ((grp) * 4)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_SWITCH_MAKE_GRP_PATTERN(FuncGrp,FuncNo) \
|
|
|
|
|
|
+ ((SD_FUNC_NO_SELECT_MASK & (~(0xF << SD_SWITCH_MAKE_SHIFT(FuncGrp)))) | \
|
|
|
|
|
|
+ (((FuncNo) & 0xF) << SD_SWITCH_MAKE_SHIFT(FuncGrp))) \
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_SWITCH_FUNC_ARG_GROUP_CHECK(FuncGrp,FuncNo) \
|
|
|
|
|
|
+ (SD_SWITCH_FUNC_CHECK | SD_SWITCH_MAKE_GRP_PATTERN(FuncGrp,FuncNo))
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_SWITCH_FUNC_ARG_GROUP_SET(FuncGrp,FuncNo) \
|
|
|
|
|
|
+ (SD_SWITCH_FUNC_SET | SD_SWITCH_MAKE_GRP_PATTERN(FuncGrp,FuncNo))
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_SWITCH_FUNC_STATUS_BLOCK_BYTES 64
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_SWITCH_FUNC_STATUS_GET_GRP_BIT_MASK(pBuffer,FuncGrp) \
|
|
|
|
|
|
+ (USHORT)((pBuffer)[50 + ((FuncGrp)*2)] | ((pBuffer)[51 + ((FuncGrp)*2)] << 8))
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SD_SWITCH_FUNC_STATUS_GET_MAX_CURRENT(pBuffer) \
|
|
|
|
|
|
+ (USHORT)((pBuffer)[62] | ((pBuffer)[63] << 8))
|
|
|
|
|
|
+
|
|
|
|
|
|
+static INLINE UINT8 SDSwitchGetSwitchResult(PUINT8 pBuffer, UINT8 FuncGrp)
|
|
|
|
|
|
+{
|
|
|
|
|
|
+ switch (FuncGrp) {
|
|
|
|
|
|
+ case 0:
|
|
|
|
|
|
+ return (pBuffer[47] & 0xF);
|
|
|
|
|
|
+ case 1:
|
|
|
|
|
|
+ return (pBuffer[47] >> 4);
|
|
|
|
|
|
+ case 2:
|
|
|
|
|
|
+ return (pBuffer[48] & 0xF);
|
|
|
|
|
|
+ case 3:
|
|
|
|
|
|
+ return (pBuffer[48] >> 4);
|
|
|
|
|
|
+ case 4:
|
|
|
|
|
|
+ return (pBuffer[49] & 0xF);
|
|
|
|
|
|
+ case 5:
|
|
|
|
|
|
+ return (pBuffer[49] >> 4);
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ return 0xF;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
diff --git a/include/linux/sdio/ctsystem.h b/include/linux/sdio/ctsystem.h
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..4f72739
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/include/linux/sdio/ctsystem.h
|
|
|
|
|
|
@@ -0,0 +1,115 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: cpsystem.h
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: common system include file.
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#ifndef __CPSYSTEM_H___
|
|
|
|
|
|
+#define __CPSYSTEM_H___
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SDIO stack status defines */
|
|
|
|
|
|
+/* < 0 error, >0 warning, 0 success */
|
|
|
|
|
|
+#define SDIO_IS_WARNING(status) ((status) > 0)
|
|
|
|
|
|
+#define SDIO_IS_ERROR(status) ((status) < 0)
|
|
|
|
|
|
+#define SDIO_SUCCESS(status) ((SDIO_STATUS)(status) >= 0)
|
|
|
|
|
|
+#define SDIO_STATUS_SUCCESS 0
|
|
|
|
|
|
+#define SDIO_STATUS_ERROR -1
|
|
|
|
|
|
+#define SDIO_STATUS_INVALID_PARAMETER -2
|
|
|
|
|
|
+#define SDIO_STATUS_PENDING 3
|
|
|
|
|
|
+#define SDIO_STATUS_DEVICE_NOT_FOUND -4
|
|
|
|
|
|
+#define SDIO_STATUS_DEVICE_ERROR -5
|
|
|
|
|
|
+#define SDIO_STATUS_INTERRUPTED -6
|
|
|
|
|
|
+#define SDIO_STATUS_NO_RESOURCES -7
|
|
|
|
|
|
+#define SDIO_STATUS_CANCELED -8
|
|
|
|
|
|
+#define SDIO_STATUS_BUFFER_TOO_SMALL -9
|
|
|
|
|
|
+#define SDIO_STATUS_NO_MORE_MESSAGES -10
|
|
|
|
|
|
+#define SDIO_STATUS_BUS_RESP_TIMEOUT -20 /* response timed-out */
|
|
|
|
|
|
+#define SDIO_STATUS_BUS_READ_TIMEOUT -21 /* read data timed-out */
|
|
|
|
|
|
+#define SDIO_STATUS_BUS_READ_CRC_ERR -22 /* data CRC failed */
|
|
|
|
|
|
+#define SDIO_STATUS_BUS_WRITE_ERROR -23 /* write failed */
|
|
|
|
|
|
+#define SDIO_STATUS_BUS_RESP_CRC_ERR -24 /* response received with a CRC error */
|
|
|
|
|
|
+#define SDIO_STATUS_INVALID_TUPLE_LENGTH -25 /* tuple length was invalid */
|
|
|
|
|
|
+#define SDIO_STATUS_TUPLE_NOT_FOUND -26 /* tuple could not be found */
|
|
|
|
|
|
+#define SDIO_STATUS_CIS_OUT_OF_RANGE -27 /* CIS is out of range in the tuple scan */
|
|
|
|
|
|
+#define SDIO_STATUS_FUNC_ENABLE_TIMEOUT -28 /* card timed out enabling or disabling */
|
|
|
|
|
|
+#define SDIO_STATUS_DATA_STATE_INVALID -29 /* card is in an invalid state for data */
|
|
|
|
|
|
+#define SDIO_STATUS_DATA_ERROR_UNKNOWN -30 /* card cannot process data transfer */
|
|
|
|
|
|
+#define SDIO_STATUS_INVALID_FUNC -31 /* sdio request is not valid for the function */
|
|
|
|
|
|
+#define SDIO_STATUS_FUNC_ARG_ERROR -32 /* sdio request argument is invalid or out of range */
|
|
|
|
|
|
+#define SDIO_STATUS_INVALID_COMMAND -33 /* SD COMMAND is invalid for the card state */
|
|
|
|
|
|
+#define SDIO_STATUS_SDREQ_QUEUE_FAILED -34 /* request failed to insert into queue */
|
|
|
|
|
|
+#define SDIO_STATUS_BUS_RESP_TIMEOUT_SHIFTABLE -35 /* response timed-out, possibily shiftable to correct */
|
|
|
|
|
|
+#define SDIO_STATUS_UNSUPPORTED -36 /* not supported */
|
|
|
|
|
|
+#define SDIO_STATUS_PROGRAM_TIMEOUT -37 /* memory card programming timeout */
|
|
|
|
|
|
+#define SDIO_STATUS_PROGRAM_STATUS_ERROR -38 /* memory card programming errors */
|
|
|
|
|
|
+
|
|
|
|
|
|
+#include <linux/sdio/ctsystem_linux.h>
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* get structure from contained field */
|
|
|
|
|
|
+#define CONTAINING_STRUCT(address, struct_type, field_name)\
|
|
|
|
|
|
+ ((struct_type *)((ULONG_PTR)(address) - (ULONG_PTR)(&((struct_type *)0)->field_name)))
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define ZERO_OBJECT(obj) memset(&(obj),0,sizeof(obj))
|
|
|
|
|
|
+#define ZERO_POBJECT(pObj) memset((pObj),0,sizeof(*(pObj)))
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* bit field support functions */
|
|
|
|
|
|
+static INLINE void SetBit(PULONG pField, UINT position) {
|
|
|
|
|
|
+ *pField |= 1 << position;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+static INLINE void ClearBit(PULONG pField, UINT position) {
|
|
|
|
|
|
+ *pField &= ~(1 << position);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+static INLINE BOOL IsBitSet(PULONG pField, UINT position) {
|
|
|
|
|
|
+ return (*pField & (1 << position));
|
|
|
|
|
|
+}
|
|
|
|
|
|
+static INLINE INT FirstClearBit(PULONG pField) {
|
|
|
|
|
|
+ UINT ii;
|
|
|
|
|
|
+ for(ii = 0; ii < sizeof(ULONG)*8; ii++) {
|
|
|
|
|
|
+ if (!IsBitSet(pField, ii)) {
|
|
|
|
|
|
+ return ii;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ /* no clear bits found */
|
|
|
|
|
|
+ return -1;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+#endif /* __CPSYSTEM_H___ */
|
|
|
|
|
|
diff --git a/include/linux/sdio/ctsystem_linux.h b/include/linux/sdio/ctsystem_linux.h
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..0de89a6
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/include/linux/sdio/ctsystem_linux.h
|
|
|
|
|
|
@@ -0,0 +1,983 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: ctsystem_linux.h
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: common system include file for Linux.
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#ifndef __CPSYSTEM_LINUX_H___
|
|
|
|
|
|
+#define __CPSYSTEM_LINUX_H___
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* #define DBG_TIMESTAMP 1 */
|
|
|
|
|
|
+#define SD_TRACK_REQ 1
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* LINUX support */
|
|
|
|
|
|
+#include <linux/version.h>
|
|
|
|
|
|
+
|
|
|
|
|
|
+#ifndef KERNEL_VERSION
|
|
|
|
|
|
+ #error KERNEL_VERSION macro not defined!
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+
|
|
|
|
|
|
+#ifndef LINUX_VERSION_CODE
|
|
|
|
|
|
+ #error LINUX_VERSION_CODE macro not defined!
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+
|
|
|
|
|
|
+#include <linux/autoconf.h>
|
|
|
|
|
|
+#include <linux/kernel.h>
|
|
|
|
|
|
+#include <linux/init.h>
|
|
|
|
|
|
+#include <linux/types.h>
|
|
|
|
|
|
+#include <linux/spinlock.h>
|
|
|
|
|
|
+#include <linux/module.h>
|
|
|
|
|
|
+
|
|
|
|
|
|
+#include <linux/interrupt.h>
|
|
|
|
|
|
+#include <linux/pnp.h>
|
|
|
|
|
|
+#include <asm/hardirq.h>
|
|
|
|
|
|
+#include <asm/semaphore.h>
|
|
|
|
|
|
+#include <asm/io.h>
|
|
|
|
|
|
+#include <asm/scatterlist.h>
|
|
|
|
|
|
+#ifdef DBG_TIMESTAMP
|
|
|
|
|
|
+#include <asm/timex.h>
|
|
|
|
|
|
+#endif /* DBG_TIMESTAMP */
|
|
|
|
|
|
+#ifndef in_atomic
|
|
|
|
|
|
+ /* released version of 2.6.9 */
|
|
|
|
|
|
+#include <linux/hardirq.h>
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+#include <linux/delay.h>
|
|
|
|
|
|
+#include <linux/device.h>
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* generic types */
|
|
|
|
|
|
+typedef unsigned char UCHAR;
|
|
|
|
|
|
+typedef unsigned char * PUCHAR;
|
|
|
|
|
|
+typedef char TEXT;
|
|
|
|
|
|
+typedef char * PTEXT;
|
|
|
|
|
|
+typedef unsigned short USHORT;
|
|
|
|
|
|
+typedef unsigned short* PUSHORT;
|
|
|
|
|
|
+typedef unsigned int UINT;
|
|
|
|
|
|
+typedef unsigned int* PUINT;
|
|
|
|
|
|
+typedef int INT;
|
|
|
|
|
|
+typedef int* PINT;
|
|
|
|
|
|
+typedef unsigned long ULONG;
|
|
|
|
|
|
+typedef unsigned long* PULONG;
|
|
|
|
|
|
+typedef u8 UINT8;
|
|
|
|
|
|
+typedef u16 UINT16;
|
|
|
|
|
|
+typedef u32 UINT32;
|
|
|
|
|
|
+typedef u8* PUINT8;
|
|
|
|
|
|
+typedef u16* PUINT16;
|
|
|
|
|
|
+typedef u32* PUINT32;
|
|
|
|
|
|
+typedef unsigned char * ULONG_PTR;
|
|
|
|
|
|
+typedef void* PVOID;
|
|
|
|
|
|
+typedef unsigned char BOOL;
|
|
|
|
|
|
+typedef BOOL* PBOOL;
|
|
|
|
|
|
+typedef int SDIO_STATUS;
|
|
|
|
|
|
+typedef int SYSTEM_STATUS;
|
|
|
|
|
|
+typedef unsigned int EVENT_TYPE;
|
|
|
|
|
|
+typedef unsigned int EVENT_ARG;
|
|
|
|
|
|
+typedef unsigned int* PEVENT_TYPE;
|
|
|
|
|
|
+typedef struct semaphore OS_SEMAPHORE;
|
|
|
|
|
|
+typedef struct semaphore* POS_SEMAPHORE;
|
|
|
|
|
|
+typedef struct semaphore OS_SIGNAL; /* OS signals are just semaphores */
|
|
|
|
|
|
+typedef struct semaphore* POS_SIGNAL;
|
|
|
|
|
|
+typedef spinlock_t OS_CRITICALSECTION;
|
|
|
|
|
|
+typedef spinlock_t *POS_CRITICALSECTION;
|
|
|
|
|
|
+typedef int SDPOWER_STATE;
|
|
|
|
|
|
+typedef unsigned long ATOMIC_FLAGS;
|
|
|
|
|
|
+typedef INT THREAD_RETURN;
|
|
|
|
|
|
+typedef dma_addr_t DMA_ADDRESS;
|
|
|
|
|
|
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9)
|
|
|
|
|
|
+typedef struct task_struct* PKERNEL_TASK;
|
|
|
|
|
|
+typedef struct device_driver OS_DRIVER;
|
|
|
|
|
|
+typedef struct device_driver* POS_DRIVER;
|
|
|
|
|
|
+typedef struct device OS_DEVICE;
|
|
|
|
|
|
+typedef struct device* POS_DEVICE;
|
|
|
|
|
|
+typedef struct pnp_driver OS_PNPDRIVER;
|
|
|
|
|
|
+typedef struct pnp_driver* POS_PNPDRIVER;
|
|
|
|
|
|
+typedef struct pnp_dev OS_PNPDEVICE;
|
|
|
|
|
|
+typedef struct pnp_dev* POS_PNPDEVICE;
|
|
|
|
|
|
+typedef struct module* POS_MODULE;
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+/* 2.4 */
|
|
|
|
|
|
+typedef int PKERNEL_TASK;
|
|
|
|
|
|
+typedef PVOID OS_DRIVER;
|
|
|
|
|
|
+typedef PVOID* POS_DRIVER;
|
|
|
|
|
|
+typedef PVOID OS_DEVICE;
|
|
|
|
|
|
+typedef PVOID* POS_DEVICE;
|
|
|
|
|
|
+typedef PVOID OS_PNPDRIVER;
|
|
|
|
|
|
+typedef PVOID* POS_PNPDRIVER;
|
|
|
|
|
|
+typedef PVOID OS_PNPDEVICE;
|
|
|
|
|
|
+typedef PVOID* POS_PNPDEVICE;
|
|
|
|
|
|
+typedef struct module* POS_MODULE;
|
|
|
|
|
|
+#define module_param(a,b,c) MODULE_PARM(a, "i")
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef int CT_DEBUG_LEVEL;
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+#ifndef TRUE
|
|
|
|
|
|
+#define TRUE 1
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+#ifndef FALSE
|
|
|
|
|
|
+#define FALSE 0
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+#ifndef NULL
|
|
|
|
|
|
+#define NULL ((PVOID)0)
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+#define SDDMA_DESCRIPTION_FLAG_DMA 0x1 /* DMA enabled */
|
|
|
|
|
|
+#define SDDMA_DESCRIPTION_FLAG_SGDMA 0x2 /* Scatter-Gather DMA enabled */
|
|
|
|
|
|
+typedef struct _SDDMA_DESCRIPTION {
|
|
|
|
|
|
+ UINT16 Flags; /* SDDMA_DESCRIPTION_FLAG_xxx */
|
|
|
|
|
|
+ UINT16 MaxDescriptors; /* number of supported scatter gather entries */
|
|
|
|
|
|
+ UINT32 MaxBytesPerDescriptor; /* maximum bytes in a DMA descriptor entry */
|
|
|
|
|
|
+ u64 Mask; /* dma address mask */
|
|
|
|
|
|
+ UINT32 AddressAlignment; /* dma address alignment mask, least significant bits indicate illegal address bits */
|
|
|
|
|
|
+ UINT32 LengthAlignment; /* dma buffer length alignment mask, least significant bits indicate illegal length bits */
|
|
|
|
|
|
+}SDDMA_DESCRIPTION, *PSDDMA_DESCRIPTION;
|
|
|
|
|
|
+typedef struct scatterlist SDDMA_DESCRIPTOR, *PSDDMA_DESCRIPTOR;
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define INLINE inline
|
|
|
|
|
|
+#define CT_PACK_STRUCT __attribute__ ((packed))
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define CT_DECLARE_MODULE_PARAM_INTEGER(p) module_param(p, int, 0644);
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* debug print macros */
|
|
|
|
|
|
+//#define SDDBG_KERNEL_PRINT_LEVEL KERN_DEBUG
|
|
|
|
|
|
+#define SDDBG_KERNEL_PRINT_LEVEL KERN_ALERT
|
|
|
|
|
|
+#define DBG_MASK_NONE 0x0
|
|
|
|
|
|
+#define DBG_MASK_HCD 0x100
|
|
|
|
|
|
+#define DBG_MASK_LIB 0x200
|
|
|
|
|
|
+#define DBG_MASK_BUS 0x400
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* debug output levels, this must be order low number to higher */
|
|
|
|
|
|
+#define SDDBG_ERROR 3
|
|
|
|
|
|
+#define SDDBG_WARN 4
|
|
|
|
|
|
+#define SDDBG_DEBUG 6
|
|
|
|
|
|
+#define SDDBG_TRACE 7
|
|
|
|
|
|
+#define SDDBG_ALL 0xff
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define DBG_LEVEL_NONE 0
|
|
|
|
|
|
+#define DBG_LEVEL_ERROR SDDBG_ERROR
|
|
|
|
|
|
+#define DBG_LEVEL_WARN SDDBG_WARN
|
|
|
|
|
|
+#define DBG_LEVEL_DEBUG SDDBG_DEBUG
|
|
|
|
|
|
+#define DBG_LEVEL_TRACE SDDBG_TRACE
|
|
|
|
|
|
+#define DBG_LEVEL_ALL SDDBG_ALL
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define DBG_GET_LEVEL(lvl) ((lvl) & 0xff)
|
|
|
|
|
|
+#define DBG_GET_MASK(lvl) (((lvl) & 0xff00))
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define DBG_SDIO_MASK (DBG_MASK_NONE | DBG_LEVEL_DEBUG)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define DEBUG 1
|
|
|
|
|
|
+
|
|
|
|
|
|
+#ifdef DEBUG
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define DBG_ASSERT(test) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ if (!(test)) { \
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("Debug Assert Caught, File %s, Line: %d, Test:%s \n",__FILE__, __LINE__,#test)); \
|
|
|
|
|
|
+ } \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+#define DBG_ASSERT_WITH_MSG(test,s) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ if (!(test)) { \
|
|
|
|
|
|
+ DBG_PRINT(SDDBG_ERROR, ("Assert:%s File %s, Line: %d \n",(s),__FILE__, __LINE__)); \
|
|
|
|
|
|
+ } \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define DBG_PRINT(lvl, args)\
|
|
|
|
|
|
+ do {\
|
|
|
|
|
|
+ if (DBG_GET_LEVEL(lvl) <= (DBG_SDIO_MASK & 0xff)) \
|
|
|
|
|
|
+ printk(_DBG_PRINTX_ARG args); \
|
|
|
|
|
|
+ } while(0);
|
|
|
|
|
|
+
|
|
|
|
|
|
+#else /* DEBUG */
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define DBG_PRINT(lvl, str)
|
|
|
|
|
|
+#define DBG_ASSERT(test)
|
|
|
|
|
|
+#define DBG_ASSERT_WITH_MSG(test,s)
|
|
|
|
|
|
+#endif /* DEBUG */
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define _DBG_PRINTX_ARG(arg...) arg /* unroll the parens around the var args*/
|
|
|
|
|
|
+#define DBG_GET_DEBUG_LEVEL() DBG_GET_LEVEL(DBG_SDIO_MASK)
|
|
|
|
|
|
+#define DBG_SET_DEBUG_LEVEL(v)
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Print a string to the debugger or console
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: REL_PRINT
|
|
|
|
|
|
+ @prototype: void REL_PRINT(INT Level, string)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+ @input: Level - debug level for the print
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return:
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: If Level is less than the current debug level, the print will be
|
|
|
|
|
|
+ issued. This print cannot be conditionally compiled.
|
|
|
|
|
|
+ @see also: DBG_PRINT
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define REL_PRINT(lvl, args)\
|
|
|
|
|
|
+ {if (lvl <= DBG_GET_DEBUG_LEVEL())\
|
|
|
|
|
|
+ printk(SDDBG_KERNEL_PRINT_LEVEL _DBG_PRINTX_ARG args);\
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+/* debug output levels, this must be order low number to higher */
|
|
|
|
|
|
+#define SDDBG_ERROR 3
|
|
|
|
|
|
+#define SDDBG_WARN 4
|
|
|
|
|
|
+#define SDDBG_DEBUG 6
|
|
|
|
|
|
+#define SDDBG_TRACE 7
|
|
|
|
|
|
+
|
|
|
|
|
|
+#ifdef DBG_CRIT_SECTION_RECURSE
|
|
|
|
|
|
+ /* this macro thows an exception if the lock is recursively taken
|
|
|
|
|
|
+ * the kernel must be configured with: CONFIG_DEBUG_SPINLOCK=y */
|
|
|
|
|
|
+#define call_spin_lock(pCrit) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ UINT32 unlocked = 1; \
|
|
|
|
|
|
+ if ((pCrit)->lock) {unlocked = 0;} \
|
|
|
|
|
|
+ spin_lock_bh(pCrit); \
|
|
|
|
|
|
+ if (!unlocked) { \
|
|
|
|
|
|
+ unlocked = 0x01; \
|
|
|
|
|
|
+ unlocked = *((volatile UINT32 *)unlocked); \
|
|
|
|
|
|
+ } \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define call_spin_lock_irqsave(pCrit,isc) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ UINT32 unlocked = 1; \
|
|
|
|
|
|
+ if ((pCrit)->lock) {unlocked = 0;} \
|
|
|
|
|
|
+ spin_lock_irqsave(pCrit,isc); \
|
|
|
|
|
|
+ if (!unlocked) { \
|
|
|
|
|
|
+ unlocked = 0x01; \
|
|
|
|
|
|
+ unlocked = *((volatile UINT32 *)unlocked); \
|
|
|
|
|
|
+ } \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+#define call_spin_lock(s) spin_lock_bh(s)
|
|
|
|
|
|
+#define call_spin_lock_irqsave(s,isc) spin_lock_irqsave(s,isc)
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define call_spin_unlock(s) spin_unlock_bh((s))
|
|
|
|
|
|
+#define call_spin_unlock_irqrestore(s,isc) spin_unlock_irqrestore(s,isc)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9)
|
|
|
|
|
|
+#define NonSchedulable() (in_atomic() || irqs_disabled())
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+#define NonSchedulable() (irqs_disabled())
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Initialize a critical section object.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: CriticalSectionInit
|
|
|
|
|
|
+ @prototype: SDIO_STATUS CriticalSectionInit(POS_CRITICALSECTION pCrit)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+ @output: pCrit - pointer to critical section to initialize
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS_SUCCESS on success.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: CriticalSectionDelete() must be called to cleanup any resources
|
|
|
|
|
|
+ associated with the critical section.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: CriticalSectionDelete, CriticalSectionAcquire, CriticalSectionRelease
|
|
|
|
|
|
+ @example: To initialize a critical section:
|
|
|
|
|
|
+ status = CriticalSectionInit(&pDevice->ListLock);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ .. failed
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline SDIO_STATUS CriticalSectionInit(POS_CRITICALSECTION pCrit) {
|
|
|
|
|
|
+ spin_lock_init(pCrit);
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Acquire a critical section lock.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: CriticalSectionAcquire
|
|
|
|
|
|
+ @prototype: SDIO_STATUS CriticalSectionAcquire(POS_CRITICALSECTION pCrit)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pCrit - pointer to critical section that was initialized
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS_SUCCESS on success.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: The critical section lock is acquired when this function returns
|
|
|
|
|
|
+ SDIO_STATUS_SUCCESS. Use CriticalSectionRelease() to release
|
|
|
|
|
|
+ the critical section lock.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: CriticalSectionRelease
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: To acquire a critical section lock:
|
|
|
|
|
|
+ status = CriticalSectionAcquire(&pDevice->ListLock);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ .. failed
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ ... access protected data
|
|
|
|
|
|
+ // unlock
|
|
|
|
|
|
+ status = CriticalSectionRelease(&pDevice->ListLock);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ .. failed
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline SDIO_STATUS CriticalSectionAcquire(POS_CRITICALSECTION pCrit) {
|
|
|
|
|
|
+ call_spin_lock(pCrit);
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+// macro-tized versions
|
|
|
|
|
|
+#define CriticalSectionAcquire_M(pCrit) \
|
|
|
|
|
|
+ SDIO_STATUS_SUCCESS; call_spin_lock(pCrit)
|
|
|
|
|
|
+#define CriticalSectionRelease_M(pCrit) \
|
|
|
|
|
|
+ SDIO_STATUS_SUCCESS; call_spin_unlock(pCrit)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define CT_DECLARE_IRQ_SYNC_CONTEXT() unsigned long _ctSyncFlags
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define CriticalSectionAcquireSyncIrq(pCrit) \
|
|
|
|
|
|
+ SDIO_STATUS_SUCCESS; call_spin_lock_irqsave(pCrit,_ctSyncFlags)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define CriticalSectionReleaseSyncIrq(pCrit) \
|
|
|
|
|
|
+ SDIO_STATUS_SUCCESS; call_spin_unlock_irqrestore(pCrit,_ctSyncFlags)
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Release a critical section lock.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: CriticalSectionRelease
|
|
|
|
|
|
+ @prototype: SDIO_STATUS CriticalSectionRelease(POS_CRITICALSECTION pCrit)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pCrit - pointer to critical section that was initialized
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS_SUCCESS on success.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: The critical section lock is released when this function returns
|
|
|
|
|
|
+ SDIO_STATUS_SUCCESS.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: CriticalSectionAcquire
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: see CriticalSectionAcquire
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline SDIO_STATUS CriticalSectionRelease(POS_CRITICALSECTION pCrit) {
|
|
|
|
|
|
+ call_spin_unlock(pCrit);
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Cleanup a critical section object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: CriticalSectionDelete
|
|
|
|
|
|
+ @prototype: void CriticalSectionDelete(POS_CRITICALSECTION pCrit)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pCrit - an initialized critical section object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS_SUCCESS on success.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: CriticalSectionInit, CriticalSectionAcquire, CriticalSectionRelease
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline void CriticalSectionDelete(POS_CRITICALSECTION pCrit) {
|
|
|
|
|
|
+ return;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* internal use */
|
|
|
|
|
|
+static inline SDIO_STATUS SignalInitialize(POS_SIGNAL pSignal) {
|
|
|
|
|
|
+ sema_init(pSignal, 0);
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/* internal use */
|
|
|
|
|
|
+static inline void SignalDelete(POS_SIGNAL pSignal) {
|
|
|
|
|
|
+ return;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/* internal use */
|
|
|
|
|
|
+static inline SDIO_STATUS SignalWaitInterruptible(POS_SIGNAL pSignal) {
|
|
|
|
|
|
+ DBG_ASSERT_WITH_MSG(!NonSchedulable(),"SignalWaitInterruptible not allowed\n");
|
|
|
|
|
|
+ if (down_interruptible(pSignal) == 0) {
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ return SDIO_STATUS_INTERRUPTED;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/* internal use */
|
|
|
|
|
|
+static inline SDIO_STATUS SignalWait(POS_SIGNAL pSignal) {
|
|
|
|
|
|
+ DBG_ASSERT_WITH_MSG(!NonSchedulable(),"SignalWait not allowed\n");
|
|
|
|
|
|
+ down(pSignal);
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* internal use */
|
|
|
|
|
|
+static inline SDIO_STATUS SignalSet(POS_SIGNAL pSignal) {
|
|
|
|
|
|
+ up(pSignal);
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Initialize a semaphore object.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SemaphoreInitialize
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SemaphoreInitialize(POS_SEMAPHORE pSem, UINT value)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: value - initial value of the semaphore
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: pSem - pointer to a semaphore object to initialize
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS_SUCCESS on success.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: SemaphoreDelete() must be called to cleanup any resources
|
|
|
|
|
|
+ associated with the semaphore
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SemaphoreDelete, SemaphorePend, SemaphorePendInterruptable
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: To initialize a semaphore:
|
|
|
|
|
|
+ status = SemaphoreInitialize(&pDevice->ResourceSem,1);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ .. failed
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline SDIO_STATUS SemaphoreInitialize(POS_SEMAPHORE pSem, UINT value) {
|
|
|
|
|
|
+ sema_init(pSem, value);
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Cleanup a semaphore object.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SemaphoreDelete
|
|
|
|
|
|
+ @prototype: void SemaphoreDelete(POS_SEMAPHORE pSem)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pSem - pointer to a semaphore object to cleanup
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return:
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SemaphoreInitialize
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline void SemaphoreDelete(POS_SEMAPHORE pSem) {
|
|
|
|
|
|
+ return;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Acquire the semaphore or pend if the resource is not available
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SemaphorePend
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SemaphorePend(POS_SEMAPHORE pSem)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pSem - pointer to an initialized semaphore object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS_SUCCESS on success.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: If the semaphore count is zero this function blocks until the count
|
|
|
|
|
|
+ becomes non-zero, otherwise the count is decremented and execution
|
|
|
|
|
|
+ continues. While waiting, the task/thread cannot be interrupted.
|
|
|
|
|
|
+ If the task or thread should be interruptible, use SemaphorePendInterruptible.
|
|
|
|
|
|
+ On some OSes SemaphorePend and SemaphorePendInterruptible behave the same.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SemaphorePendInterruptable, SemaphorePost
|
|
|
|
|
|
+ @example: To wait for a resource using a semaphore:
|
|
|
|
|
|
+ status = SemaphorePend(&pDevice->ResourceSem);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ .. failed
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ ... resource acquired
|
|
|
|
|
|
+ SemaphorePost(&pDevice->ResourceSem);
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline SDIO_STATUS SemaphorePend(POS_SEMAPHORE pSem) {
|
|
|
|
|
|
+ DBG_ASSERT_WITH_MSG(!NonSchedulable(),"SemaphorePend not allowed\n");
|
|
|
|
|
|
+ down(pSem);
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Acquire the semaphore or pend if the resource is not available
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SemaphorePendInterruptable
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SemaphorePendInterruptable(POS_SEMAPHORE pSem)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pSem - pointer to an initialized semaphore object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS_SUCCESS on success.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: If the semaphore count is zero this function blocks until the count
|
|
|
|
|
|
+ becomes non-zero, otherwise the count is decremented and execution
|
|
|
|
|
|
+ continues. While waiting, the task/thread can be interrupted.
|
|
|
|
|
|
+ If the task or thread should not be interruptible, use SemaphorePend.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SemaphorePend, SemaphorePost
|
|
|
|
|
|
+ @example: To wait for a resource using a semaphore:
|
|
|
|
|
|
+ status = SemaphorePendInterruptable(&pDevice->ResourceSem);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ .. failed, could have been interrupted
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ ... resource acquired
|
|
|
|
|
|
+ SemaphorePost(&pDevice->ResourceSem);
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline SDIO_STATUS SemaphorePendInterruptable(POS_SEMAPHORE pSem) {
|
|
|
|
|
|
+ DBG_ASSERT_WITH_MSG(!NonSchedulable(),"SemaphorePendInterruptable not allowed\n");
|
|
|
|
|
|
+ if (down_interruptible(pSem) == 0) {
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ } else {
|
|
|
|
|
|
+ return SDIO_STATUS_INTERRUPTED;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Post a semaphore.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SemaphorePost
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SemaphorePost(POS_SEMAPHORE pSem)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pSem - pointer to an initialized semaphore object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS_SUCCESS on success.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This function increments the semaphore count.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SemaphorePend, SemaphorePendInterruptable.
|
|
|
|
|
|
+ @example: Posting a semaphore:
|
|
|
|
|
|
+ status = SemaphorePendInterruptable(&pDevice->ResourceSem);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ .. failed, could have been interrupted
|
|
|
|
|
|
+ return status;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ ... resource acquired
|
|
|
|
|
|
+ // post the semaphore
|
|
|
|
|
|
+ SemaphorePost(&pDevice->ResourceSem);
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline SDIO_STATUS SemaphorePost(POS_SEMAPHORE pSem) {
|
|
|
|
|
|
+ DBG_ASSERT_WITH_MSG(!NonSchedulable(),"SemaphorePost not allowed\n");
|
|
|
|
|
|
+ up(pSem);
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Allocate a block of kernel accessible memory
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: KernelAlloc
|
|
|
|
|
|
+ @prototype: PVOID KernelAlloc(UINT size)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: size - size of memory block to allocate
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: pointer to the allocated memory, NULL if allocation failed
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: For operating systems that use paging, the allocated memory is always
|
|
|
|
|
|
+ non-paged memory. Caller should only use KernelFree() to release the
|
|
|
|
|
|
+ block of memory. This call can potentially block and should only be called
|
|
|
|
|
|
+ from a schedulable context. Use KernelAllocIrqSafe() if the allocation
|
|
|
|
|
|
+ must be made from a non-schedulable context.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: KernelFree, KernelAllocIrqSafe
|
|
|
|
|
|
+ @example: allocating memory:
|
|
|
|
|
|
+ pBlock = KernelAlloc(1024);
|
|
|
|
|
|
+ if (pBlock == NULL) {
|
|
|
|
|
|
+ .. failed, no memory
|
|
|
|
|
|
+ return SDIO_STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline PVOID KernelAlloc(UINT size) {
|
|
|
|
|
|
+ PVOID pMem = kmalloc(size, GFP_KERNEL);
|
|
|
|
|
|
+ if (pMem != NULL) { memset(pMem,0,size); }
|
|
|
|
|
|
+ return pMem;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Free a block of kernel accessible memory.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: KernelFree
|
|
|
|
|
|
+ @prototype: void KernelFree(PVOID ptr)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: ptr - pointer to memory allocated with KernelAlloc()
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return:
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Caller should only use KernelFree() to release memory that was allocated
|
|
|
|
|
|
+ with KernelAlloc().
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: KernelAlloc
|
|
|
|
|
|
+ @example: KernelFree(pBlock);
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline void KernelFree(PVOID ptr) {
|
|
|
|
|
|
+ kfree(ptr);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Allocate a block of kernel accessible memory in an IRQ-safe manner
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: KernelAllocIrqSafe
|
|
|
|
|
|
+ @prototype: PVOID KernelAllocIrqSafe(UINT size)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: size - size of memory block to allocate
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: pointer to the allocated memory, NULL if allocation failed
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This variant of KernelAlloc allows the allocation of small blocks of
|
|
|
|
|
|
+ memory from an ISR or from a context where scheduling has been disabled.
|
|
|
|
|
|
+ The allocations should be small as the memory is typically allocated
|
|
|
|
|
|
+ from a critical heap. The caller should only use KernelFreeIrqSafe()
|
|
|
|
|
|
+ to release the block of memory.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: KernelAlloc, KernelFreeIrqSafe
|
|
|
|
|
|
+ @example: allocating memory:
|
|
|
|
|
|
+ pBlock = KernelAllocIrqSafe(16);
|
|
|
|
|
|
+ if (pBlock == NULL) {
|
|
|
|
|
|
+ .. failed, no memory
|
|
|
|
|
|
+ return SDIO_STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline PVOID KernelAllocIrqSafe(UINT size) {
|
|
|
|
|
|
+ return kmalloc(size, GFP_ATOMIC);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Free a block of kernel accessible memory.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: KernelFreeIrqSafe
|
|
|
|
|
|
+ @prototype: void KernelFreeIrqSafe(PVOID ptr)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: ptr - pointer to memory allocated with KernelAllocIrqSafe()
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return:
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Caller should only use KernelFreeIrqSafe() to release memory that was allocated
|
|
|
|
|
|
+ with KernelAllocIrqSafe().
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: KernelAllocIrqSafe
|
|
|
|
|
|
+ @example: KernelFreeIrqSafe(pBlock);
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline void KernelFreeIrqSafe(PVOID ptr) {
|
|
|
|
|
|
+ kfree(ptr);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* error status conversions */
|
|
|
|
|
|
+static inline SYSTEM_STATUS SDIOErrorToOSError(SDIO_STATUS status) {
|
|
|
|
|
|
+ switch (status) {
|
|
|
|
|
|
+ case SDIO_STATUS_SUCCESS:
|
|
|
|
|
|
+ return 0;
|
|
|
|
|
|
+ case SDIO_STATUS_INVALID_PARAMETER:
|
|
|
|
|
|
+ return -EINVAL;
|
|
|
|
|
|
+ case SDIO_STATUS_PENDING:
|
|
|
|
|
|
+ return -EAGAIN; /* try again */
|
|
|
|
|
|
+ case SDIO_STATUS_DEVICE_NOT_FOUND:
|
|
|
|
|
|
+ return -ENXIO;
|
|
|
|
|
|
+ case SDIO_STATUS_DEVICE_ERROR:
|
|
|
|
|
|
+ return -EIO;
|
|
|
|
|
|
+ case SDIO_STATUS_INTERRUPTED:
|
|
|
|
|
|
+ return -EINTR;
|
|
|
|
|
|
+ case SDIO_STATUS_NO_RESOURCES:
|
|
|
|
|
|
+ return -ENOMEM;
|
|
|
|
|
|
+ case SDIO_STATUS_ERROR:
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ return -EFAULT;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+static inline SDIO_STATUS OSErrorToSDIOError(SYSTEM_STATUS status) {
|
|
|
|
|
|
+ if (status >=0) {
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ switch (status) {
|
|
|
|
|
|
+ case -EINVAL:
|
|
|
|
|
|
+ return SDIO_STATUS_INVALID_PARAMETER;
|
|
|
|
|
|
+ case -ENXIO:
|
|
|
|
|
|
+ return SDIO_STATUS_DEVICE_NOT_FOUND;
|
|
|
|
|
|
+ case -EIO:
|
|
|
|
|
|
+ return SDIO_STATUS_DEVICE_ERROR;
|
|
|
|
|
|
+ case -EINTR:
|
|
|
|
|
|
+ return SDIO_STATUS_INTERRUPTED;
|
|
|
|
|
|
+ case -ENOMEM:
|
|
|
|
|
|
+ return SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ case -EFAULT:
|
|
|
|
|
|
+ return SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ default:
|
|
|
|
|
|
+ return SDIO_STATUS_ERROR;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Sleep or delay the execution context for a number of milliseconds.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: OSSleep
|
|
|
|
|
|
+ @prototype: SDIO_STATUS OSSleep(INT SleepInterval)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: SleepInterval - time in milliseconds to put the execution context to sleep
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS_SUCCESS if sleep succeeded.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Caller should be in a context that allows it to sleep or block. The
|
|
|
|
|
|
+ minimum duration of sleep may be greater than 1 MS on some platforms and OSes.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: OSSleep
|
|
|
|
|
|
+ @example: Using sleep to delay
|
|
|
|
|
|
+ EnableSlotPower(pSlot);
|
|
|
|
|
|
+ // wait for power to settle
|
|
|
|
|
|
+ status = OSSleep(100);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)){
|
|
|
|
|
|
+ // failed..
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static inline SDIO_STATUS OSSleep(INT SleepInterval) {
|
|
|
|
|
|
+ UINT32 delta;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ DBG_ASSERT_WITH_MSG(!NonSchedulable(),"OSSleep not allowed\n");
|
|
|
|
|
|
+ /* convert timeout to ticks */
|
|
|
|
|
|
+ delta = (SleepInterval * HZ)/1000;
|
|
|
|
|
|
+ if (delta == 0) {
|
|
|
|
|
|
+ delta = 1;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
|
|
+ if (schedule_timeout(delta) != 0) {
|
|
|
|
|
|
+ return SDIO_STATUS_INTERRUPTED;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return SDIO_STATUS_SUCCESS;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: get the OSs device object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SD_GET_OS_DEVICE
|
|
|
|
|
|
+ @prototype: POS_DEVICE SD_GET_OS_DEVICE(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the device on the HCD
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: pointer to the OSs device
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also:
|
|
|
|
|
|
+ @example: obtain low level device
|
|
|
|
|
|
+ pFunctionContext->GpsDevice.Port.dev = SD_GET_OS_DEVICE(pDevice);
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SD_GET_OS_DEVICE(pDevice) &((pDevice)->Device.dev)
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+#ifdef __iomem
|
|
|
|
|
|
+ /* new type checking in 2.6.9 */
|
|
|
|
|
|
+ /* I/O Access macros */
|
|
|
|
|
|
+#define _READ_DWORD_REG(reg) \
|
|
|
|
|
|
+ readl((const volatile void __iomem *)(reg))
|
|
|
|
|
|
+#define _READ_WORD_REG(reg) \
|
|
|
|
|
|
+ readw((const volatile void __iomem *)(reg))
|
|
|
|
|
|
+#define _READ_BYTE_REG(reg) \
|
|
|
|
|
|
+ readb((const volatile void __iomem *)(reg))
|
|
|
|
|
|
+#define _WRITE_DWORD_REG(reg,value) \
|
|
|
|
|
|
+ writel((value),(volatile void __iomem *)(reg))
|
|
|
|
|
|
+#define _WRITE_WORD_REG(reg,value) \
|
|
|
|
|
|
+ writew((value),(volatile void __iomem *)(reg))
|
|
|
|
|
|
+#define _WRITE_BYTE_REG(reg,value) \
|
|
|
|
|
|
+ writeb((value),(volatile void __iomem *)(reg))
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+ /* I/O Access macros */
|
|
|
|
|
|
+#define _READ_DWORD_REG(reg) \
|
|
|
|
|
|
+ readl((reg))
|
|
|
|
|
|
+#define _READ_WORD_REG(reg) \
|
|
|
|
|
|
+ readw((reg))
|
|
|
|
|
|
+#define _READ_BYTE_REG(reg) \
|
|
|
|
|
|
+ readb((reg))
|
|
|
|
|
|
+#define _WRITE_DWORD_REG(reg,value) \
|
|
|
|
|
|
+ writel((value),(reg))
|
|
|
|
|
|
+#define _WRITE_WORD_REG(reg,value) \
|
|
|
|
|
|
+ writew((value),(reg))
|
|
|
|
|
|
+#define _WRITE_BYTE_REG(reg,value) \
|
|
|
|
|
|
+ writeb((value),(reg))
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
+ /* atomic operators */
|
|
|
|
|
|
+static inline ATOMIC_FLAGS AtomicTest_Set(volatile ATOMIC_FLAGS *pValue, INT BitNo) {
|
|
|
|
|
|
+ return test_and_set_bit(BitNo,(ATOMIC_FLAGS *)pValue);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+static inline ATOMIC_FLAGS AtomicTest_Clear(volatile ATOMIC_FLAGS *pValue, INT BitNo) {
|
|
|
|
|
|
+ return test_and_clear_bit(BitNo,(ATOMIC_FLAGS *)pValue);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+struct _OSKERNEL_HELPER;
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef THREAD_RETURN (*PHELPER_FUNCTION)(struct _OSKERNEL_HELPER *);
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef struct _OSKERNEL_HELPER {
|
|
|
|
|
|
+ PKERNEL_TASK pTask;
|
|
|
|
|
|
+ BOOL ShutDown;
|
|
|
|
|
|
+ OS_SIGNAL WakeSignal;
|
|
|
|
|
|
+ struct completion Completion;
|
|
|
|
|
|
+ PVOID pContext;
|
|
|
|
|
|
+ PHELPER_FUNCTION pHelperFunc;
|
|
|
|
|
|
+}OSKERNEL_HELPER, *POSKERNEL_HELPER;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Wake the helper thread
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SD_WAKE_OS_HELPER
|
|
|
|
|
|
+ @prototype: SD_WAKE_OS_HELPER(POSKERNEL_HELPER pOSHelper)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pOSHelper - the OS helper object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_OSCreateHelper
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Waking up a helper thread
|
|
|
|
|
|
+ status = SD_WAKE_OS_HELPER(&pInstance->OSHelper);
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SD_WAKE_OS_HELPER(p) SignalSet(&(p)->WakeSignal)
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Obtains the context for the helper function
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SD_GET_OS_HELPER_CONTEXT
|
|
|
|
|
|
+ @prototype: SD_GET_OS_HELPER_CONTEXT(POSKERNEL_HELPER pOSHelper)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pOSHelper - the OS helper object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: helper specific context
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This macro should only be called by the function associated with
|
|
|
|
|
|
+ the helper object.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_OSCreateHelper
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Getting the helper specific context
|
|
|
|
|
|
+ PMYCONTEXT pContext = (PMYCONTEXT)SD_GET_OS_HELPER_CONTEXT(pHelper);
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SD_GET_OS_HELPER_CONTEXT(p) (p)->pContext
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Check helper function shut down flag.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SD_IS_HELPER_SHUTTING_DOWN
|
|
|
|
|
|
+ @prototype: SD_IS_HELPER_SHUTTING_DOWN(POSKERNEL_HELPER pOSHelper)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pOSHelper - the OS helper object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: TRUE if shutting down, else FALSE
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This macro should only be called by the function associated with
|
|
|
|
|
|
+ the helper object. The function should call this macro when it
|
|
|
|
|
|
+ unblocks from the call to SD_WAIT_FOR_WAKEUP(). If this function
|
|
|
|
|
|
+ returns TRUE, the function should clean up and exit.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_OSCreateHelper , SD_WAIT_FOR_WAKEUP
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Checking for shutdown
|
|
|
|
|
|
+ while(1) {
|
|
|
|
|
|
+ status = SD_WAIT_FOR_WAKEUP(pHelper);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SD_IS_HELPER_SHUTTING_DOWN(pHelper)) {
|
|
|
|
|
|
+ ... shutting down
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SD_IS_HELPER_SHUTTING_DOWN(p) (p)->ShutDown
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Suspend and wait for wakeup signal
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SD_WAIT_FOR_WAKEUP
|
|
|
|
|
|
+ @prototype: SD_WAIT_FOR_WAKEUP(POSKERNEL_HELPER pOSHelper)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pOSHelper - the OS helper object
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This macro should only be called by the function associated with
|
|
|
|
|
|
+ the helper object. The function should call this function to suspend (block)
|
|
|
|
|
|
+ itself and wait for a wake up signal. The function should always check
|
|
|
|
|
|
+ whether the function should exit by calling SD_IS_HELPER_SHUTTING_DOWN.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_OSCreateHelper , SD_IS_HELPER_SHUTTING_DOWN
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: block on the wake signal
|
|
|
|
|
|
+ while(1) {
|
|
|
|
|
|
+ status = SD_WAIT_FOR_WAKEUP(pHelper);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (SD_IS_HELPER_SHUTTING_DOWN(pHelper)) {
|
|
|
|
|
|
+ ... shutting down
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SD_WAIT_FOR_WAKEUP(p) SignalWait(&(p)->WakeSignal);
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define CT_LE16_TO_CPU_ENDIAN(x) __le16_to_cpu(x)
|
|
|
|
|
|
+#define CT_LE32_TO_CPU_ENDIAN(x) __le32_to_cpu(x)
|
|
|
|
|
|
+#define CT_CPU_ENDIAN_TO_LE16(x) __cpu_to_le16(x)
|
|
|
|
|
|
+#define CT_CPU_ENDIAN_TO_LE32(x) __cpu_to_le32(x)
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define CT_CPU_ENDIAN_TO_BE16(x) __cpu_to_be16(x)
|
|
|
|
|
|
+#define CT_CPU_ENDIAN_TO_BE32(x) __cpu_to_be32(x)
|
|
|
|
|
|
+#define CT_BE16_TO_CPU_ENDIAN(x) __be16_to_cpu(x)
|
|
|
|
|
|
+#define CT_BE32_TO_CPU_ENDIAN(x) __be32_to_cpu(x)
|
|
|
|
|
|
+#endif /* __CPSYSTEM_LINUX_H___ */
|
|
|
|
|
|
+
|
|
|
|
|
|
diff --git a/include/linux/sdio/mmc_defs.h b/include/linux/sdio/mmc_defs.h
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..576ebd7
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/include/linux/sdio/mmc_defs.h
|
|
|
|
|
|
@@ -0,0 +1,103 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: mmc_defs.h
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: MMC definitions not already defined in _sdio_defs.h
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#ifndef ___MMC_DEFS_H___
|
|
|
|
|
|
+#define ___MMC_DEFS_H___
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define MMC_MAX_BUS_CLOCK 20000000 /* max clock speed in hz */
|
|
|
|
|
|
+#define MMC_HS_MAX_BUS_CLOCK 52000000 /* MMC PLUS (high speed) max clock rate in hz */
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* R2 (CSD) macros */
|
|
|
|
|
|
+#define GET_MMC_CSD_TRANS_SPEED(pR) (pR)[12]
|
|
|
|
|
|
+#define GET_MMC_SPEC_VERSION(pR) (((pR)[15] >> 2) & 0x0F)
|
|
|
|
|
|
+#define MMC_SPEC_1_0_TO_1_2 0x00
|
|
|
|
|
|
+#define MMC_SPEC_1_4 0x01
|
|
|
|
|
|
+#define MMC_SPEC_2_0_TO_2_2 0x02
|
|
|
|
|
|
+#define MMC_SPEC_3_1 0x03
|
|
|
|
|
|
+#define MMC_SPEC_4_0_TO_4_1 0x04
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define MMC_CMD_SWITCH 6
|
|
|
|
|
|
+#define MMC_CMD8 8
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define MMC_SWITCH_CMD_SET 0
|
|
|
|
|
|
+#define MMC_SWITCH_SET_BITS 1
|
|
|
|
|
|
+#define MMC_SWITCH_CLEAR_BITS 2
|
|
|
|
|
|
+#define MMC_SWITCH_WRITE_BYTE 3
|
|
|
|
|
|
+#define MMC_SWITCH_CMD_SET0 0
|
|
|
|
|
|
+#define MMC_SWITCH_BUILD_ARG(cmdset,access,index,value) \
|
|
|
|
|
|
+ (((cmdset) & 0x07) | (((access) & 0x03) << 24) | (((index) & 0xFF) << 16) | (((value) & 0xFF) << 8))
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define MMC_EXT_CSD_SIZE 512
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define MMC_EXT_S_CMD_SET_OFFSET 504
|
|
|
|
|
|
+#define MMC_EXT_MIN_PERF_W_8_52_OFFSET 210
|
|
|
|
|
|
+#define MMC_EXT_MIN_PERF_R_8_52_OFFSET 209
|
|
|
|
|
|
+#define MMC_EXT_MIN_PERF_W_8_26_4_52_OFFSET 208
|
|
|
|
|
|
+#define MMC_EXT_MIN_PERF_R_8_26_4_52_OFFSET 207
|
|
|
|
|
|
+#define MMC_EXT_MIN_PERF_W_4_26_OFFSET 206
|
|
|
|
|
|
+#define MMC_EXT_MIN_PERF_R_4_56_OFFSET 205
|
|
|
|
|
|
+#define MMC_EXT_PWR_CL_26_360_OFFSET 203
|
|
|
|
|
|
+#define MMC_EXT_PWR_CL_52_360_OFFSET 202
|
|
|
|
|
|
+#define MMC_EXT_PWR_CL_26_195_OFFSET 201
|
|
|
|
|
|
+#define MMC_EXT_PWR_CL_52_195_OFFSET 200
|
|
|
|
|
|
+#define MMC_EXT_GET_PWR_CLASS(reg) ((reg) & 0xF)
|
|
|
|
|
|
+#define MMC_EXT_MAX_PWR_CLASSES 16
|
|
|
|
|
|
+#define MMC_EXT_CARD_TYPE_OFFSET 196
|
|
|
|
|
|
+#define MMC_EXT_CARD_TYPE_HS_52 (1 << 1)
|
|
|
|
|
|
+#define MMC_EXT_CARD_TYPE_HS_26 (1 << 0)
|
|
|
|
|
|
+#define MMC_EXT_CSD_VER_OFFSET 194
|
|
|
|
|
|
+#define MMC_EXT_VER_OFFSET 192
|
|
|
|
|
|
+#define MMC_EXT_VER_1_0 0
|
|
|
|
|
|
+#define MMC_EXT_VER_1_1 1
|
|
|
|
|
|
+#define MMC_EXT_CMD_SET_OFFSET 191
|
|
|
|
|
|
+#define MMC_EXT_CMD_SET_REV_OFFSET 189
|
|
|
|
|
|
+#define MMC_EXT_PWR_CLASS_OFFSET 187
|
|
|
|
|
|
+#define MMC_EXT_HS_TIMING_OFFSET 185
|
|
|
|
|
|
+#define MMC_EXT_HS_TIMING_ENABLE 0x01
|
|
|
|
|
|
+#define MMC_EXT_BUS_WIDTH_OFFSET 183
|
|
|
|
|
|
+#define MMC_EXT_BUS_WIDTH_1_BIT 0x00
|
|
|
|
|
|
+#define MMC_EXT_BUS_WIDTH_4_BIT 0x01
|
|
|
|
|
|
+#define MMC_EXT_BUS_WIDTH_8_BIT 0x02
|
|
|
|
|
|
+
|
|
|
|
|
|
+#endif
|
|
|
|
|
|
diff --git a/include/linux/sdio/sdio_busdriver.h b/include/linux/sdio/sdio_busdriver.h
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..b431d3d
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/include/linux/sdio/sdio_busdriver.h
|
|
|
|
|
|
@@ -0,0 +1,1435 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: sdio_busdriver.h
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: include file for registration of SDIO function drivers
|
|
|
|
|
|
+ and SDIO host controller bus drivers.
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#ifndef __SDIO_BUSDRIVER_H___
|
|
|
|
|
|
+#define __SDIO_BUSDRIVER_H___
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef UINT8 CT_VERSION_CODE;
|
|
|
|
|
|
+#define CT_SDIO_STACK_VERSION_CODE ((CT_VERSION_CODE)0x26) /* version code that must be set in various structures */
|
|
|
|
|
|
+#define CT_SDIO_STACK_VERSION_MAJOR(v) (((v) & 0xF0) >> 4)
|
|
|
|
|
|
+#define CT_SDIO_STACK_VERSION_MINOR(v) (((v) & 0x0F))
|
|
|
|
|
|
+#define SET_SDIO_STACK_VERSION(p) (p)->Version = CT_SDIO_STACK_VERSION_CODE
|
|
|
|
|
|
+#define GET_SDIO_STACK_VERSION(p) (p)->Version
|
|
|
|
|
|
+#define GET_SDIO_STACK_VERSION_MAJOR(p) CT_SDIO_STACK_VERSION_MAJOR(GET_SDIO_STACK_VERSION(p))
|
|
|
|
|
|
+#define GET_SDIO_STACK_VERSION_MINOR(p) CT_SDIO_STACK_VERSION_MINOR(GET_SDIO_STACK_VERSION(p))
|
|
|
|
|
|
+#include "sdlist.h"
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* card flags */
|
|
|
|
|
|
+typedef UINT16 CARD_INFO_FLAGS;
|
|
|
|
|
|
+#define CARD_MMC 0x0001 /* Multi-media card */
|
|
|
|
|
|
+#define CARD_SD 0x0002 /* SD-Memory present */
|
|
|
|
|
|
+#define CARD_SDIO 0x0004 /* SDIO present */
|
|
|
|
|
|
+#define CARD_RAW 0x0008 /* Raw card */
|
|
|
|
|
|
+#define CARD_COMBO (CARD_SD | CARD_SDIO) /* SDIO with SD */
|
|
|
|
|
|
+#define CARD_TYPE_MASK 0x000F /* card type mask */
|
|
|
|
|
|
+#define CARD_SD_WP 0x0010 /* SD WP on */
|
|
|
|
|
|
+#define CARD_PSEUDO 0x0020 /* pseudo card (internal use) */
|
|
|
|
|
|
+#define CARD_HIPWR 0x0040 /* card can use more than 200mA (SDIO 1.1 or greater)*/
|
|
|
|
|
|
+#define GET_CARD_TYPE(flags) ((flags) & CARD_TYPE_MASK)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* bus mode and clock rate */
|
|
|
|
|
|
+typedef UINT32 SD_BUSCLOCK_RATE; /* clock rate in hz */
|
|
|
|
|
|
+typedef UINT16 SD_BUSMODE_FLAGS;
|
|
|
|
|
|
+#define SDCONFIG_BUS_WIDTH_RESERVED 0x00
|
|
|
|
|
|
+#define SDCONFIG_BUS_WIDTH_SPI 0x01
|
|
|
|
|
|
+#define SDCONFIG_BUS_WIDTH_1_BIT 0x02
|
|
|
|
|
|
+#define SDCONFIG_BUS_WIDTH_4_BIT 0x03
|
|
|
|
|
|
+#define SDCONFIG_BUS_WIDTH_MMC8_BIT 0x04
|
|
|
|
|
|
+#define SDCONFIG_BUS_WIDTH_MASK 0x0F
|
|
|
|
|
|
+#define SDCONFIG_SET_BUS_WIDTH(flags,width) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ (flags) &= ~SDCONFIG_BUS_WIDTH_MASK; \
|
|
|
|
|
|
+ (flags) |= (width); \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+#define SDCONFIG_GET_BUSWIDTH(flags) ((flags) & SDCONFIG_BUS_WIDTH_MASK)
|
|
|
|
|
|
+#define SDCONFIG_BUS_MODE_SPI_NO_CRC 0x40 /* SPI bus is operating with NO CRC */
|
|
|
|
|
|
+#define SDCONFIG_BUS_MODE_SD_HS 0x80 /* set interface to SD high speed mode */
|
|
|
|
|
|
+#define SDCONFIG_BUS_MODE_MMC_HS 0x20 /* set interface to MMC high speed mode */
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef UINT16 SD_SLOT_CURRENT; /* slot current in mA */
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef UINT8 SLOT_VOLTAGE_MASK; /* slot voltage */
|
|
|
|
|
|
+#define SLOT_POWER_3_3V 0x01
|
|
|
|
|
|
+#define SLOT_POWER_3_0V 0x02
|
|
|
|
|
|
+#define SLOT_POWER_2_8V 0x04
|
|
|
|
|
|
+#define SLOT_POWER_2_0V 0x08
|
|
|
|
|
|
+#define SLOT_POWER_1_8V 0x10
|
|
|
|
|
|
+#define SLOT_POWER_1_6V 0x20
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define MAX_CARD_RESPONSE_BYTES 17
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* plug and play information for SD cards */
|
|
|
|
|
|
+typedef struct _SD_PNP_INFO {
|
|
|
|
|
|
+ UINT16 SDIO_ManufacturerCode; /* JEDEC Code */
|
|
|
|
|
|
+ UINT16 SDIO_ManufacturerID; /* manf-specific ID */
|
|
|
|
|
|
+ UINT8 SDIO_FunctionNo; /* function number 1-7 */
|
|
|
|
|
|
+ UINT8 SDIO_FunctionClass; /* function class */
|
|
|
|
|
|
+ UINT8 SDMMC_ManfacturerID; /* card CID's MANF-ID */
|
|
|
|
|
|
+ UINT16 SDMMC_OEMApplicationID; /* card CID's OEMAPP-ID */
|
|
|
|
|
|
+ CARD_INFO_FLAGS CardFlags; /* card flags */
|
|
|
|
|
|
+}SD_PNP_INFO, *PSD_PNP_INFO;
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define IS_LAST_SDPNPINFO_ENTRY(id)\
|
|
|
|
|
|
+ (((id)->SDIO_ManufacturerCode == 0) &&\
|
|
|
|
|
|
+ ((id)->SDIO_ManufacturerID == 0) &&\
|
|
|
|
|
|
+ ((id)->SDIO_FunctionNo == 0) &&\
|
|
|
|
|
|
+ ((id)->SDIO_FunctionClass == 0) &&\
|
|
|
|
|
|
+ ((id)->SDMMC_OEMApplicationID == 0) && \
|
|
|
|
|
|
+ ((id)->CardFlags == 0))
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* card properties */
|
|
|
|
|
|
+typedef struct _CARD_PROPERTIES {
|
|
|
|
|
|
+ UINT8 IOFnCount; /* number of I/O functions */
|
|
|
|
|
|
+ UINT8 SDIORevision; /* SDIO revision */
|
|
|
|
|
|
+#define SDIO_REVISION_1_00 0x00
|
|
|
|
|
|
+#define SDIO_REVISION_1_10 0x01
|
|
|
|
|
|
+#define SDIO_REVISION_1_20 0x02
|
|
|
|
|
|
+ UINT8 SD_MMC_Revision; /* SD or MMC revision */
|
|
|
|
|
|
+#define SD_REVISION_1_01 0x00
|
|
|
|
|
|
+#define SD_REVISION_1_10 0x01
|
|
|
|
|
|
+#define MMC_REVISION_1_0_2_2 0x00
|
|
|
|
|
|
+#define MMC_REVISION_3_1 0x01
|
|
|
|
|
|
+#define MMC_REVISION_4_0 0x02
|
|
|
|
|
|
+ UINT16 SDIO_ManufacturerCode; /* JEDEC Code */
|
|
|
|
|
|
+ UINT16 SDIO_ManufacturerID; /* manf-specific ID */
|
|
|
|
|
|
+ UINT32 CommonCISPtr; /* common CIS ptr */
|
|
|
|
|
|
+ UINT16 RCA; /* relative card address */
|
|
|
|
|
|
+ UINT8 SDIOCaps; /* SDIO card capabilities (refer to SDIO spec for decoding) */
|
|
|
|
|
|
+ UINT8 CardCSD[MAX_CARD_RESPONSE_BYTES]; /* for SD/MMC cards */
|
|
|
|
|
|
+ CARD_INFO_FLAGS Flags; /* card flags */
|
|
|
|
|
|
+ SD_BUSCLOCK_RATE OperBusClock; /* operational bus clock (based on HCD limit)*/
|
|
|
|
|
|
+ SD_BUSMODE_FLAGS BusMode; /* current card bus mode */
|
|
|
|
|
|
+ UINT16 OperBlockLenLimit; /* operational bytes per block length limit*/
|
|
|
|
|
|
+ UINT16 OperBlockCountLimit; /* operational number of blocks per transfer limit */
|
|
|
|
|
|
+ UINT8 CardState; /* card state flags */
|
|
|
|
|
|
+ SLOT_VOLTAGE_MASK CardVoltage; /* card operational voltage */
|
|
|
|
|
|
+#define CARD_STATE_REMOVED 0x01
|
|
|
|
|
|
+}CARD_PROPERTIES, *PCARD_PROPERTIES;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SDREQUEST request flags */
|
|
|
|
|
|
+typedef UINT32 SDREQUEST_FLAGS;
|
|
|
|
|
|
+/* write operation */
|
|
|
|
|
|
+#define SDREQ_FLAGS_DATA_WRITE 0x8000
|
|
|
|
|
|
+/* has data (read or write) */
|
|
|
|
|
|
+#define SDREQ_FLAGS_DATA_TRANS 0x4000
|
|
|
|
|
|
+/* command is an atomic APP command, requiring CMD55 to be issued */
|
|
|
|
|
|
+#define SDREQ_FLAGS_APP_CMD 0x2000
|
|
|
|
|
|
+/* transfer should be handled asynchronously */
|
|
|
|
|
|
+#define SDREQ_FLAGS_TRANS_ASYNC 0x1000
|
|
|
|
|
|
+/* host should skip the SPI response filter for this command */
|
|
|
|
|
|
+#define SDREQ_FLAGS_RESP_SKIP_SPI_FILT 0x0800
|
|
|
|
|
|
+/* host should skip the response check for this data transfer */
|
|
|
|
|
|
+#define SDREQ_FLAGS_DATA_SKIP_RESP_CHK 0x0400
|
|
|
|
|
|
+/* flag requesting a CMD12 be automatically issued by host controller */
|
|
|
|
|
|
+#define SDREQ_FLAGS_AUTO_CMD12 0x0200
|
|
|
|
|
|
+/* flag indicating that the data buffer meets HCD's DMA restrictions */
|
|
|
|
|
|
+#define SDREQ_FLAGS_DATA_DMA 0x0010
|
|
|
|
|
|
+/* indicate to host that this is a short and quick transfer, the HCD may optimize
|
|
|
|
|
|
+ * this request to reduce interrupt overhead */
|
|
|
|
|
|
+#define SDREQ_FLAGS_DATA_SHORT_TRANSFER 0x00010000
|
|
|
|
|
|
+/* indicate to the host that this is a raw request */
|
|
|
|
|
|
+#define SDREQ_FLAGS_RAW 0x00020000
|
|
|
|
|
|
+/* auto data transfer status check for MMC and Memory cards */
|
|
|
|
|
|
+#define SDREQ_FLAGS_AUTO_TRANSFER_STATUS 0x00100000
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDREQ_FLAGS_UNUSED1 0x00200000
|
|
|
|
|
|
+#define SDREQ_FLAGS_UNUSED2 0x00400000
|
|
|
|
|
|
+#define SDREQ_FLAGS_UNUSED3 0x00800000
|
|
|
|
|
|
+#define SDREQ_FLAGS_UNUSED4 0x01000000
|
|
|
|
|
|
+#define SDREQ_FLAGS_UNUSED5 0x02000000
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* the following flags are internal use only */
|
|
|
|
|
|
+#define SDREQ_FLAGS_FORCE_DEFERRED_COMPLETE 0x0100
|
|
|
|
|
|
+/* flag indicating that response has been converted (internal use) */
|
|
|
|
|
|
+#define SDREQ_FLAGS_RESP_SPI_CONVERTED 0x0040
|
|
|
|
|
|
+/* request was cancelled - internal use only */
|
|
|
|
|
|
+#define SDREQ_FLAGS_CANCELED 0x0020
|
|
|
|
|
|
+/* a barrier operation */
|
|
|
|
|
|
+#define SDREQ_FLAGS_BARRIER 0x00040000
|
|
|
|
|
|
+/* a pseudo bus request */
|
|
|
|
|
|
+#define SDREQ_FLAGS_PSEUDO 0x00080000
|
|
|
|
|
|
+/* queue to the head */
|
|
|
|
|
|
+#define SDREQ_FLAGS_QUEUE_HEAD 0x04000000
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDREQ_FLAGS_I_UNUSED1 0x08000000
|
|
|
|
|
|
+#define SDREQ_FLAGS_I_UNUSED2 0x10000000
|
|
|
|
|
|
+#define SDREQ_FLAGS_I_UNUSED3 0x20000000
|
|
|
|
|
|
+#define SDREQ_FLAGS_I_UNUSED4 0x40000000
|
|
|
|
|
|
+#define SDREQ_FLAGS_I_UNUSED5 0x80000000
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* response type mask */
|
|
|
|
|
|
+#define SDREQ_FLAGS_RESP_MASK 0x000F
|
|
|
|
|
|
+#define GET_SDREQ_RESP_TYPE(flags) ((flags) & SDREQ_FLAGS_RESP_MASK)
|
|
|
|
|
|
+#define IS_SDREQ_WRITE_DATA(flags) ((flags) & SDREQ_FLAGS_DATA_WRITE)
|
|
|
|
|
|
+#define IS_SDREQ_DATA_TRANS(flags) ((flags) & SDREQ_FLAGS_DATA_TRANS)
|
|
|
|
|
|
+#define IS_SDREQ_RAW(flags) ((flags) & SDREQ_FLAGS_RAW)
|
|
|
|
|
|
+#define IS_SDREQ_FORCE_DEFERRED_COMPLETE(flags) ((flags) & SDREQ_FLAGS_FORCE_DEFERRED_COMPLETE)
|
|
|
|
|
|
+#define SDREQ_FLAGS_NO_RESP 0x0000
|
|
|
|
|
|
+#define SDREQ_FLAGS_RESP_R1 0x0001
|
|
|
|
|
|
+#define SDREQ_FLAGS_RESP_R1B 0x0002
|
|
|
|
|
|
+#define SDREQ_FLAGS_RESP_R2 0x0003
|
|
|
|
|
|
+#define SDREQ_FLAGS_RESP_R3 0x0004
|
|
|
|
|
|
+#define SDREQ_FLAGS_RESP_MMC_R4 0x0005 /* not supported, for future use */
|
|
|
|
|
|
+#define SDREQ_FLAGS_RESP_MMC_R5 0x0006 /* not supported, for future use */
|
|
|
|
|
|
+#define SDREQ_FLAGS_RESP_R6 0x0007
|
|
|
|
|
|
+#define SDREQ_FLAGS_RESP_SDIO_R4 0x0008
|
|
|
|
|
|
+#define SDREQ_FLAGS_RESP_SDIO_R5 0x0009
|
|
|
|
|
|
+
|
|
|
|
|
|
+struct _SDREQUEST;
|
|
|
|
|
|
+struct _SDFUNCTION;
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef void (*PSDEQUEST_COMPLETION)(struct _SDREQUEST *);
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* defines SD/MMC and SDIO requests for the RAW-mode API */
|
|
|
|
|
|
+typedef struct _SDREQUEST {
|
|
|
|
|
|
+ SDLIST SDList; /* internal use list*/
|
|
|
|
|
|
+ UINT32 Argument; /* SD/SDIO/MMC 32 bit argument */
|
|
|
|
|
|
+ SDREQUEST_FLAGS Flags; /* request flags */
|
|
|
|
|
|
+ ATOMIC_FLAGS InternalFlags; /* internal use flags */
|
|
|
|
|
|
+ UINT8 Command; /* SD/SDIO/MMC 8 bit command */
|
|
|
|
|
|
+ UINT8 Response[MAX_CARD_RESPONSE_BYTES]; /* buffer for CMD response */
|
|
|
|
|
|
+ UINT16 BlockCount; /* number of blocks to send/rcv */
|
|
|
|
|
|
+ UINT16 BlockLen; /* length of each block */
|
|
|
|
|
|
+ UINT16 DescriptorCount; /* number of DMA descriptor entries in pDataBuffer if DMA */
|
|
|
|
|
|
+ PVOID pDataBuffer; /* starting address of buffer (or ptr to PSDDMA_DESCRIPTOR*/
|
|
|
|
|
|
+ UINT32 DataRemaining; /* number of bytes remaining in the transfer (internal use) */
|
|
|
|
|
|
+ PVOID pHcdContext; /* internal use context */
|
|
|
|
|
|
+ PSDEQUEST_COMPLETION pCompletion; /* function driver completion routine */
|
|
|
|
|
|
+ PVOID pCompleteContext; /* function driver completion context */
|
|
|
|
|
|
+ SDIO_STATUS Status; /* completion status */
|
|
|
|
|
|
+ struct _SDFUNCTION* pFunction; /* function driver that generated request (internal use)*/
|
|
|
|
|
|
+ INT RetryCount; /* number of times to retry on error, non-data cmds only */
|
|
|
|
|
|
+ PVOID pBdRsv1; /* reserved */
|
|
|
|
|
|
+ PVOID pBdRsv2;
|
|
|
|
|
|
+ PVOID pBdRsv3;
|
|
|
|
|
|
+}SDREQUEST, *PSDREQUEST;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* a request queue */
|
|
|
|
|
|
+typedef struct _SDREQUESTQUEUE {
|
|
|
|
|
|
+ SDLIST Queue; /* the queue of requests */
|
|
|
|
|
|
+ BOOL Busy; /* busy flag */
|
|
|
|
|
|
+}SDREQUESTQUEUE, *PSDREQUESTQUEUE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef UINT16 SDCONFIG_COMMAND;
|
|
|
|
|
|
+/* SDCONFIG request flags */
|
|
|
|
|
|
+/* get operation */
|
|
|
|
|
|
+#define SDCONFIG_FLAGS_DATA_GET 0x8000
|
|
|
|
|
|
+/* put operation */
|
|
|
|
|
|
+#define SDCONFIG_FLAGS_DATA_PUT 0x4000
|
|
|
|
|
|
+/* host controller */
|
|
|
|
|
|
+#define SDCONFIG_FLAGS_HC_CONFIG 0x2000
|
|
|
|
|
|
+/* both */
|
|
|
|
|
|
+#define SDCONFIG_FLAGS_DATA_BOTH (SDCONFIG_FLAGS_DATA_GET | SDCONFIG_FLAGS_DATA_PUT)
|
|
|
|
|
|
+/* no data */
|
|
|
|
|
|
+#define SDCONFIG_FLAGS_DATA_NONE 0x0000
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* SDCONFIG commands */
|
|
|
|
|
|
+#define SDCONFIG_GET_HCD_DEBUG (SDCONFIG_FLAGS_HC_CONFIG | SDCONFIG_FLAGS_DATA_GET | 275)
|
|
|
|
|
|
+#define SDCONFIG_SET_HCD_DEBUG (SDCONFIG_FLAGS_HC_CONFIG | SDCONFIG_FLAGS_DATA_PUT | 276)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* custom hcd commands */
|
|
|
|
|
|
+#define SDCONFIG_GET_HOST_CUSTOM (SDCONFIG_FLAGS_HC_CONFIG | SDCONFIG_FLAGS_DATA_GET | 300)
|
|
|
|
|
|
+#define SDCONFIG_PUT_HOST_CUSTOM (SDCONFIG_FLAGS_HC_CONFIG | SDCONFIG_FLAGS_DATA_PUT | 301)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* function commands */
|
|
|
|
|
|
+#define SDCONFIG_FUNC_ENABLE_DISABLE (SDCONFIG_FLAGS_DATA_PUT | 18)
|
|
|
|
|
|
+#define SDCONFIG_FUNC_UNMASK_IRQ (SDCONFIG_FLAGS_DATA_NONE | 21)
|
|
|
|
|
|
+#define SDCONFIG_FUNC_MASK_IRQ (SDCONFIG_FLAGS_DATA_NONE | 22)
|
|
|
|
|
|
+#define SDCONFIG_FUNC_ACK_IRQ (SDCONFIG_FLAGS_DATA_NONE | 23)
|
|
|
|
|
|
+#define SDCONFIG_FUNC_SPI_MODE_DISABLE_CRC (SDCONFIG_FLAGS_DATA_NONE | 24)
|
|
|
|
|
|
+#define SDCONFIG_FUNC_SPI_MODE_ENABLE_CRC (SDCONFIG_FLAGS_DATA_NONE | 25)
|
|
|
|
|
|
+#define SDCONFIG_FUNC_ALLOC_SLOT_CURRENT (SDCONFIG_FLAGS_DATA_PUT | 26)
|
|
|
|
|
|
+#define SDCONFIG_FUNC_FREE_SLOT_CURRENT (SDCONFIG_FLAGS_DATA_NONE | 27)
|
|
|
|
|
|
+#define SDCONFIG_FUNC_CHANGE_BUS_MODE (SDCONFIG_FLAGS_DATA_BOTH | 28)
|
|
|
|
|
|
+#define SDCONFIG_FUNC_CHANGE_BUS_MODE_ASYNC (SDCONFIG_FLAGS_DATA_BOTH | 29)
|
|
|
|
|
|
+#define SDCONFIG_FUNC_NO_IRQ_PEND_CHECK (SDCONFIG_FLAGS_DATA_NONE | 30)
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef UINT8 FUNC_ENABLE_DISABLE_FLAGS;
|
|
|
|
|
|
+typedef UINT32 FUNC_ENABLE_TIMEOUT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* function enable */
|
|
|
|
|
|
+typedef struct _SDCONFIG_FUNC_ENABLE_DISABLE_DATA {
|
|
|
|
|
|
+#define SDCONFIG_DISABLE_FUNC 0x0000
|
|
|
|
|
|
+#define SDCONFIG_ENABLE_FUNC 0x0001
|
|
|
|
|
|
+ FUNC_ENABLE_DISABLE_FLAGS EnableFlags; /* enable flags*/
|
|
|
|
|
|
+ FUNC_ENABLE_TIMEOUT TimeOut; /* timeout in milliseconds */
|
|
|
|
|
|
+ void (*pOpComplete)(PVOID Context, SDIO_STATUS status); /* reserved */
|
|
|
|
|
|
+ PVOID pOpCompleteContext; /* reserved */
|
|
|
|
|
|
+}SDCONFIG_FUNC_ENABLE_DISABLE_DATA, *PSDCONFIG_FUNC_ENABLE_DISABLE_DATA;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* slot current allocation data */
|
|
|
|
|
|
+typedef struct _SDCONFIG_FUNC_SLOT_CURRENT_DATA {
|
|
|
|
|
|
+ SD_SLOT_CURRENT SlotCurrent; /* slot current to request in mA*/
|
|
|
|
|
|
+}SDCONFIG_FUNC_SLOT_CURRENT_DATA, *PSDCONFIG_FUNC_SLOT_CURRENT_DATA;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* slot bus mode configuration */
|
|
|
|
|
|
+typedef struct _SDCONFIG_BUS_MODE_DATA {
|
|
|
|
|
|
+ SD_BUSCLOCK_RATE ClockRate; /* clock rate in Hz */
|
|
|
|
|
|
+ SD_BUSMODE_FLAGS BusModeFlags; /* bus mode flags */
|
|
|
|
|
|
+ SD_BUSCLOCK_RATE ActualClockRate; /* actual rate in KHz */
|
|
|
|
|
|
+}SDCONFIG_BUS_MODE_DATA, *PSDCONFIG_BUS_MODE_DATA;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* defines configuration requests for the HCD */
|
|
|
|
|
|
+typedef struct _SDCONFIG {
|
|
|
|
|
|
+ SDCONFIG_COMMAND Cmd; /* configuration command */
|
|
|
|
|
|
+ PVOID pData; /* configuration data */
|
|
|
|
|
|
+ INT DataLength; /* config data length */
|
|
|
|
|
|
+}SDCONFIG, *PSDCONFIG;
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SET_SDCONFIG_CMD_INFO(pHdr,cmd,pC,len) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ (pHdr)->Cmd = (cmd); \
|
|
|
|
|
|
+ (pHdr)->pData = (PVOID)(pC); \
|
|
|
|
|
|
+ (pHdr)->DataLength = (len); \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get a pointer to the configuration command data.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: GET_SDCONFIG_CMD
|
|
|
|
|
|
+ @prototype: UNIT16 GET_SDCONFIG_CMD (PSDCONFIG pCommand)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pCommand - config command structure.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: command code
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. This macro returns the command code for this
|
|
|
|
|
|
+ configuration request.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: getting the command code:
|
|
|
|
|
|
+ cmd = GET_SDCONFIG_CMD(pConfig);
|
|
|
|
|
|
+ switch (cmd) {
|
|
|
|
|
|
+ case SDCONFIG_GET_WP:
|
|
|
|
|
|
+ .. get write protect switch position
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ ...
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: GET_SDCONFIG_CMD_LEN, GET_SDCONFIG_CMD_DATA
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define GET_SDCONFIG_CMD(pBuffer) ((pBuffer)->Cmd)
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get a pointer to the configuration command data.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: GET_SDCONFIG_CMD_LEN
|
|
|
|
|
|
+ @prototype: INT GET_SDCONFIG_CMD_LEN (PSDCONFIG pCommand)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pCommand - config command structure.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: length of config command data
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. Host controller drivers can use this macro to extract
|
|
|
|
|
|
+ the number of bytes of command specific data. This can be used to validate the
|
|
|
|
|
|
+ config data buffer size.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: getting the data length:
|
|
|
|
|
|
+ length = GET_SDCONFIG_CMD_LEN(pConfig);
|
|
|
|
|
|
+ if (length < CUSTOM_COMMAND_XXX_SIZE) {
|
|
|
|
|
|
+ ... invalid length
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: GET_SDCONFIG_CMD, GET_SDCONFIG_CMD_DATA
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define GET_SDCONFIG_CMD_LEN(pBuffer) ((pBuffer)->DataLength)
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get a pointer to the configuration command data.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: GET_SDCONFIG_CMD_DATA
|
|
|
|
|
|
+ @prototype: (casted ptr) GET_SDCONFIG_CMD_DATA (type, PSDCONFIG pCommand)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: type - pointer type to cast the returned pointer to.
|
|
|
|
|
|
+ pCommand - config command structure.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: type-casted pointer to the command's data
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. Host controller drivers can use this macro to extract
|
|
|
|
|
|
+ a pointer to the command specific data in an HCD configuration request.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: getting the pointer:
|
|
|
|
|
|
+ // get interrupt control data
|
|
|
|
|
|
+ pIntControl = GET_SDCONFIG_CMD_DATA(PSDCONFIG_SDIO_INT_CTRL_DATA,pConfig);
|
|
|
|
|
|
+ if (pIntControl->SlotIRQEnable) {
|
|
|
|
|
|
+ ... enable slot IRQ detection
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: GET_SDCONFIG_CMD, GET_SDCONFIG_CMD_LEN
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define GET_SDCONFIG_CMD_DATA(type,pBuffer) ((type)((pBuffer)->pData))
|
|
|
|
|
|
+#define IS_SDCONFIG_CMD_GET(pBuffer) ((pBuffer)->Cmd & SDCONFIG_FLAGS_DATA_GET)
|
|
|
|
|
|
+#define IS_SDCONFIG_CMD_PUT(pBuffer) ((pBuffer)->Cmd & SDCONFIG_FLAGS_DATA_PUT)
|
|
|
|
|
|
+
|
|
|
|
|
|
+struct _SDDEVICE;
|
|
|
|
|
|
+struct _SDHCD;
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef UINT8 SD_FUNCTION_FLAGS;
|
|
|
|
|
|
+#define SDFUNCTION_FLAG_REMOVING 0x01
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* function driver registration structure */
|
|
|
|
|
|
+typedef struct _SDFUNCTION {
|
|
|
|
|
|
+ CT_VERSION_CODE Version; /* version code of the SDIO stack */
|
|
|
|
|
|
+ SDLIST SDList; /* internal use list*/
|
|
|
|
|
|
+ PTEXT pName; /* name of registering driver */
|
|
|
|
|
|
+ UINT MaxDevices; /* maximum number of devices supported by this function */
|
|
|
|
|
|
+ UINT NumDevices; /* number of devices supported by this function */
|
|
|
|
|
|
+ PSD_PNP_INFO pIds; /* null terminated table of supported devices*/
|
|
|
|
|
|
+ BOOL (*pProbe)(struct _SDFUNCTION *pFunction, struct _SDDEVICE *pDevice);/* New device inserted */
|
|
|
|
|
|
+ /* Device removed (NULL if not a hot-plug capable driver) */
|
|
|
|
|
|
+ void (*pRemove)(struct _SDFUNCTION *pFunction, struct _SDDEVICE *pDevice);
|
|
|
|
|
|
+ SDIO_STATUS (*pSuspend)(struct _SDFUNCTION *pFunction, SDPOWER_STATE state); /* Device suspended */
|
|
|
|
|
|
+ SDIO_STATUS (*pResume)(struct _SDFUNCTION *pFunction); /* Device woken up */
|
|
|
|
|
|
+ /* Enable wake event */
|
|
|
|
|
|
+ SDIO_STATUS (*pWake) (struct _SDFUNCTION *pFunction, SDPOWER_STATE state, BOOL enable);
|
|
|
|
|
|
+ PVOID pContext; /* function driver use data */
|
|
|
|
|
|
+ OS_PNPDRIVER Driver; /* driver registration with base system */
|
|
|
|
|
|
+ SDLIST DeviceList; /* the list of devices this driver is using*/
|
|
|
|
|
|
+ OS_SIGNAL CleanupReqSig; /* wait for requests completion on cleanup (internal use) */
|
|
|
|
|
|
+ SD_FUNCTION_FLAGS Flags; /* internal flags (internal use) */
|
|
|
|
|
|
+}SDFUNCTION, *PSDFUNCTION;
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef UINT8 HCD_EVENT;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* device info for SDIO functions */
|
|
|
|
|
|
+typedef struct _SDIO_DEVICE_INFO {
|
|
|
|
|
|
+ UINT32 FunctionCISPtr; /* function's CIS ptr */
|
|
|
|
|
|
+ UINT32 FunctionCSAPtr; /* function's CSA ptr */
|
|
|
|
|
|
+ UINT16 FunctionMaxBlockSize; /* function's reported max block size */
|
|
|
|
|
|
+}SDIO_DEVICE_INFO, *PSDIO_DEVICE_INFO;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* device info for SD/MMC card functions */
|
|
|
|
|
|
+typedef struct _SDMMC_INFO{
|
|
|
|
|
|
+ UINT8 Unused; /* reserved */
|
|
|
|
|
|
+}SDMMC_INFO, *PSDMMC_INFO;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* union of SDIO function and device info */
|
|
|
|
|
|
+typedef union _SDDEVICE_INFO {
|
|
|
|
|
|
+ SDIO_DEVICE_INFO AsSDIOInfo;
|
|
|
|
|
|
+ SDMMC_INFO AsSDMMCInfo;
|
|
|
|
|
|
+}SDDEVICE_INFO, *PSDDEVICE_INFO;
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef UINT8 SD_DEVICE_FLAGS;
|
|
|
|
|
|
+#define SDDEVICE_FLAG_REMOVING 0x01
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* inserted device description, describes an inserted card */
|
|
|
|
|
|
+typedef struct _SDDEVICE {
|
|
|
|
|
|
+ SDLIST SDList; /* internal use list*/
|
|
|
|
|
|
+ SDLIST FuncListLink; /* internal use list */
|
|
|
|
|
|
+ /* read/write request function */
|
|
|
|
|
|
+ SDIO_STATUS (*pRequest)(struct _SDDEVICE *pDev, PSDREQUEST req);
|
|
|
|
|
|
+ /* get/set configuration */
|
|
|
|
|
|
+ SDIO_STATUS (*pConfigure)(struct _SDDEVICE *pDev, PSDCONFIG config);
|
|
|
|
|
|
+ PSDREQUEST (*AllocRequest)(struct _SDDEVICE *pDev); /* allocate a request */
|
|
|
|
|
|
+ void (*FreeRequest)(struct _SDDEVICE *pDev, PSDREQUEST pReq); /* free the request */
|
|
|
|
|
|
+ void (*pIrqFunction)(PVOID pContext); /* interrupt routine, synchronous calls allowed */
|
|
|
|
|
|
+ void (*pIrqAsyncFunction)(PVOID pContext); /* async IRQ function , asynch only calls */
|
|
|
|
|
|
+ PVOID IrqContext; /* irq context */
|
|
|
|
|
|
+ PVOID IrqAsyncContext; /* irq async context */
|
|
|
|
|
|
+ PSDFUNCTION pFunction; /* function driver supporting this device */
|
|
|
|
|
|
+ struct _SDHCD *pHcd; /* host controller this device is on (internal use) */
|
|
|
|
|
|
+ SDDEVICE_INFO DeviceInfo; /* device info */
|
|
|
|
|
|
+ SD_PNP_INFO pId[1]; /* id of this device */
|
|
|
|
|
|
+ OS_PNPDEVICE Device; /* device registration with base system */
|
|
|
|
|
|
+ SD_SLOT_CURRENT SlotCurrentAlloc; /* allocated slot current for this device/function (internal use) */
|
|
|
|
|
|
+ SD_DEVICE_FLAGS Flags; /* internal use flags */
|
|
|
|
|
|
+ CT_VERSION_CODE Version; /* version code of the bus driver */
|
|
|
|
|
|
+}SDDEVICE, *PSDDEVICE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get SDIO Bus Driver Version Major number
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_VERSION_MAJOR
|
|
|
|
|
|
+ @prototype: INT SDDEVICE_GET_VERSION_MAJOR(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: integer value for the major version
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_VERSION_MINOR
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_VERSION_MAJOR(pDev) (GET_SDIO_STACK_VERSION_MAJOR(pDev))
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get SDIO Bus Driver Version Minor number
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_VERSION_MINOR
|
|
|
|
|
|
+ @prototype: INT SDDEVICE_GET_VERSION_MINOR(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: integer value for the minor version
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_VERSION_MAJOR
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_VERSION_MINOR(pDev) (GET_SDIO_STACK_VERSION_MINOR(pDev))
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Test the SDIO revision for greater than or equal to 1.10
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_IS_SDIO_REV_GTEQ_1_10
|
|
|
|
|
|
+ @prototype: BOOL SDDEVICE_IS_SDIO_REV_GTEQ_1_10(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: TRUE if the revision is greater than or equal to 1.10
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_IS_SD_REV_GTEQ_1_10
|
|
|
|
|
|
+ @see also: SDDEVICE_IS_MMC_REV_GTEQ_4_0
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_IS_SDIO_REV_GTEQ_1_10(pDev) ((pDev)->pHcd->CardProperties.SDIORevision >= SDIO_REVISION_1_10)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Test the SDIO revision for greater than or equal to 1.20
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_IS_SDIO_REV_GTEQ_1_20
|
|
|
|
|
|
+ @prototype: BOOL SDDEVICE_IS_SDIO_REV_GTEQ_1_20(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: TRUE if the revision is greater than or equal to 1.20
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_IS_SD_REV_GTEQ_1_10
|
|
|
|
|
|
+ @see also: SDDEVICE_IS_SDIO_REV_GTEQ_1_10
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_IS_SDIO_REV_GTEQ_1_20(pDev) ((pDev)->pHcd->CardProperties.SDIORevision >= SDIO_REVISION_1_20)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Test the SD revision for greater than or equal to 1.10
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_IS_SD_REV_GTEQ_1_10
|
|
|
|
|
|
+ @prototype: BOOL SDDEVICE_IS_SD_REV_GTEQ_1_10(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: TRUE if the revision is greater than or equal to 1.10
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_IS_SDIO_REV_GTEQ_1_10
|
|
|
|
|
|
+ @see also: SDDEVICE_IS_MMC_REV_GTEQ_4_0
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_IS_SD_REV_GTEQ_1_10(pDev) ((pDev)->pHcd->CardProperties.SD_MMC_Revision >= SD_REVISION_1_10)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Test the MMC revision for greater than or equal to 4.0
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_IS_MMC_REV_GTEQ_4_0
|
|
|
|
|
|
+ @prototype: BOOL SDDEVICE_IS_MMC_REV_GTEQ_4_0(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: TRUE if the revision is greater than or equal to 4.0
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_IS_SDIO_REV_GTEQ_1_10
|
|
|
|
|
|
+ @see also: SDDEVICE_IS_SD_REV_GTEQ_1_10
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_IS_MMC_REV_GTEQ_4_0(pDev) ((pDev)->pHcd->CardProperties.SD_MMC_Revision >= MMC_REVISION_4_0)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Test for write protect enabled
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_IS_CARD_WP_ON
|
|
|
|
|
|
+ @prototype: BOOL SDDEVICE_IS_CARD_WP_ON(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: TRUE if device is write protected.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_IS_CARD_WP_ON(pDev) ((pDev)->pHcd->CardProperties.Flags & CARD_SD_WP)
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the device's manufacturer specific ID
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_SDIO_MANFID
|
|
|
|
|
|
+ @prototype: UINT16 SDDEVICE_GET_SDIO_MANFID(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: function number
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_SDIO_MANFCODE
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_SDIO_MANFID(pDev) (pDev)->pId[0].SDIO_ManufacturerID
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the device's manufacturer code
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_SDIO_MANFCODE
|
|
|
|
|
|
+ @prototype: UINT16 SDDEVICE_GET_SDIO_MANFCODE(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: function number
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_SDIO_MANFID
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_SDIO_MANFCODE(pDev) (pDev)->pId[0].SDIO_ManufacturerCode
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the device's function number
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_SDIO_FUNCNO
|
|
|
|
|
|
+ @prototype: UINT8 SDDEVICE_GET_SDIO_FUNCNO(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: function number
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_SDIO_FUNC_CLASS
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_SDIO_FUNCNO(pDev) (pDev)->pId[0].SDIO_FunctionNo
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the functions's class
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_SDIO_FUNC_CLASS
|
|
|
|
|
|
+ @prototype: UINT8 SDDEVICE_GET_SDIO_FUNC_CLASS(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: class number
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_SDIO_FUNCNO
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_SDIO_FUNC_CLASS(pDev) (pDev)->pId[0].SDIO_FunctionClass
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the functions's Card Information Structure pointer
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_SDIO_FUNC_CISPTR
|
|
|
|
|
|
+ @prototype: UINT32 SDDEVICE_GET_SDIO_FUNC_CISPTR(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: CIS offset
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_SDIO_FUNC_CSAPTR
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_SDIO_COMMON_CISPTR
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_SDIO_FUNC_CISPTR(pDev)(pDev)->DeviceInfo.AsSDIOInfo.FunctionCISPtr
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the functions's Code Stoarge Area pointer
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_SDIO_FUNC_CSAPTR
|
|
|
|
|
|
+ @prototype: UINT32 SDDEVICE_GET_SDIO_FUNC_CSAPTR(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: CSA offset
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_SDIO_FUNC_CISPTR
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_SDIO_FUNC_CSAPTR(pDev)(pDev)->DeviceInfo.AsSDIOInfo.FunctionCSAPtr
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the functions's maximum reported block size
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_SDIO_FUNC_MAXBLKSIZE
|
|
|
|
|
|
+ @prototype: UINT16 SDDEVICE_GET_SDIO_FUNC_MAXBLKSIZE(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: block size
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also:
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_SDIO_FUNC_MAXBLKSIZE(pDev) (pDev)->DeviceInfo.AsSDIOInfo.FunctionMaxBlockSize
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the common Card Information Structure pointer
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_SDIO_COMMON_CISPTR
|
|
|
|
|
|
+ @prototype: UINT32 SDDEVICE_GET_SDIO_COMMON_CISPTR(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: Common CIS Address (in SDIO address space)
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_SDIO_FUNC_CSAPTR
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_SDIO_COMMON_CISPTR(pDev) (pDev)->pHcd->CardProperties.CommonCISPtr
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the card capabilities
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_SDIO_CARD_CAPS
|
|
|
|
|
|
+ @prototype: UINT8 SDDEVICE_GET_SDIO_CARD_CAPS(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: 8-bit card capabilities register
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. Refer to SDIO spec for decoding.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_CARD_FLAGS
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_SDIOCARD_CAPS
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_SDIO_CARD_CAPS(pDev) (pDev)->pHcd->CardProperties.SDIOCaps
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the card flags
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_CARD_FLAGS
|
|
|
|
|
|
+ @prototype: CARD_INFO_FLAGS SDDEVICE_GET_CARD_FLAGS(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: flags
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Get card type:
|
|
|
|
|
|
+ CARD_INFO_FLAGS flags;
|
|
|
|
|
|
+ flags = SDDEVICE_GET_CARD_FLAGS(pDevice);
|
|
|
|
|
|
+ switch(GET_CARD_TYPE(flags)) {
|
|
|
|
|
|
+ case CARD_MMC: // Multi-media card
|
|
|
|
|
|
+ ...
|
|
|
|
|
|
+ case CARD_SD: // SD-Memory present
|
|
|
|
|
|
+ ...
|
|
|
|
|
|
+ case CARD_SDIO: // SDIO card present
|
|
|
|
|
|
+ ...
|
|
|
|
|
|
+ case CARD_COMBO: //SDIO card with SD
|
|
|
|
|
|
+ ...
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (flags & CARD_SD_WP) {
|
|
|
|
|
|
+ ...SD write protect on
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_SDIO_CARD_CAPS
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_CARD_FLAGS(pDev) (pDev)->pHcd->CardProperties.Flags
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the Relative Card Address register
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_CARD_RCA
|
|
|
|
|
|
+ @prototype: UINT16 SDDEVICE_GET_CARD_RCA(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: register address
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. Refer to SDIO spec for decoding.
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_CARD_RCA(pDev) (pDev)->pHcd->CardProperties.RCA
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get operational bus clock
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_OPER_CLOCK
|
|
|
|
|
|
+ @prototype: SD_BUSCLOCK_RATE SDDEVICE_GET_OPER_CLOCK(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: clock rate
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. Returns the current bus clock rate.
|
|
|
|
|
|
+ This may be lower than reported by the card due to Host Controller,
|
|
|
|
|
|
+ Bus driver, or power management limitations.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_MAX_CLOCK
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_OPER_CLOCK(pDev) (pDev)->pHcd->CardProperties.OperBusClock
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get maximum bus clock
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_MAX_CLOCK
|
|
|
|
|
|
+ @prototype: SD_BUSCLOCK_RATE SDDEVICE_GET_MAX_CLOCK(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: clock rate
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: To obtain the current maximum clock rate use SDDEVICE_GET_OPER_CLOCK().
|
|
|
|
|
|
+ This rate my be lower than the host controllers maximum obtained using
|
|
|
|
|
|
+ SDDEVICE_GET_MAX_CLOCK().
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_OPER_CLOCK
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_MAX_CLOCK(pDev) (pDev)->pHcd->MaxClockRate
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get operational maximum block length.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_OPER_BLOCK_LEN
|
|
|
|
|
|
+ @prototype: UINT16 SDDEVICE_GET_OPER_BLOCK_LEN(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: block size in bytes
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. Returns the maximum current block length.
|
|
|
|
|
|
+ This may be lower than reported by the card due to Host Controller,
|
|
|
|
|
|
+ Bus driver, or power management limitations.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_MAX_BLOCK_LEN
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_OPER_BLOCK_LEN(pDev) (pDev)->pHcd->CardProperties.OperBlockLenLimit
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get maximum block length.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_MAX_BLOCK_LEN
|
|
|
|
|
|
+ @prototype: UINT16 SDDEVICE_GET_MAX_BLOCK_LEN(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: block size in bytes
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. Use SDDEVICE_GET_OPER_BLOCK_LEN to obtain
|
|
|
|
|
|
+ the current block length.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_OPER_BLOCK_LEN
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_MAX_BLOCK_LEN(pDev) (pDev)->pHcd->MaxBytesPerBlock
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get operational maximum block count.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_OPER_BLOCKS
|
|
|
|
|
|
+ @prototype: UINT16 SDDEVICE_GET_OPER_BLOCKS(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: maximum number of blocks per transaction.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. Returns the maximum current block count.
|
|
|
|
|
|
+ This may be lower than reported by the card due to Host Controller,
|
|
|
|
|
|
+ Bus driver, or power management limitations.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_MAX_BLOCK_LEN
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_OPER_BLOCKS(pDev) (pDev)->pHcd->CardProperties.OperBlockCountLimit
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get maximum block count.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_MAX_BLOCKS
|
|
|
|
|
|
+ @prototype: UINT16 SDDEVICE_GET_MAX_BLOCKS(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: maximum number of blocks per transaction.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. Use SDDEVICE_GET_OPER_BLOCKS to obtain
|
|
|
|
|
|
+ the current block count.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_OPER_BLOCKS
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_MAX_BLOCKS(pDev) (pDev)->pHcd->MaxBlocksPerTrans
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get applied slot voltage
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_SLOT_VOLTAGE_MASK
|
|
|
|
|
|
+ @prototype: SLOT_VOLTAGE_MASK SDDEVICE_GET_SLOT_VOLTAGE_MASK(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: slot voltage mask
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This function returns the applied voltage on the slot. The voltage value is a
|
|
|
|
|
|
+ mask having the following values:
|
|
|
|
|
|
+ SLOT_POWER_3_3V
|
|
|
|
|
|
+ SLOT_POWER_3_0V
|
|
|
|
|
|
+ SLOT_POWER_2_8V
|
|
|
|
|
|
+ SLOT_POWER_2_0V
|
|
|
|
|
|
+ SLOT_POWER_1_8V
|
|
|
|
|
|
+ SLOT_POWER_1_6V
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_SLOT_VOLTAGE_MASK(pDev) (pDev)->pHcd->CardProperties.CardVoltage
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the Card Specific Data Register.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_CARDCSD
|
|
|
|
|
|
+ @prototype: PUINT8 SDDEVICE_GET_CARDCSD(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: UINT8 CardCSD[MAX_CARD_RESPONSE_BYTES] array of CSD data.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_CARDCSD(pDev) (pDev)->pHcd->CardProperties.CardCSD
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the bus mode flags
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_BUSMODE_FLAGS
|
|
|
|
|
|
+ @prototype: SD_BUSMODE_FLAGS SDDEVICE_GET_BUSMODE_FLAGS(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return:
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. This function returns the raw bus mode flags. This
|
|
|
|
|
|
+ is useful for function drivers that wish to override the bus clock without
|
|
|
|
|
|
+ modifying the current bus mode.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_BUSWIDTH
|
|
|
|
|
|
+ @see also: SDCONFIG_BUS_MODE_CTRL
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_BUSMODE_FLAGS(pDev) (pDev)->pHcd->CardProperties.BusMode
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the bus width.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_BUSWIDTH
|
|
|
|
|
|
+ @prototype: UINT8 SDDEVICE_GET_BUSWIDTH(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: bus width: SDCONFIG_BUS_WIDTH_SPI, SDCONFIG_BUS_WIDTH_1_BIT, SDCONFIG_BUS_WIDTH_4_BIT
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_IS_BUSMODE_SPI
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_BUSWIDTH(pDev) SDCONFIG_GET_BUSWIDTH((pDev)->pHcd->CardProperties.BusMode)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Is bus in SPI mode.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_IS_BUSMODE_SPI
|
|
|
|
|
|
+ @prototype: BOOL SDDEVICE_IS_BUSMODE_SPI(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: TRUE, SPI mode.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_BUSWIDTH
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_IS_BUSMODE_SPI(pDev) (SDDEVICE_GET_BUSWIDTH(pDev) == SDCONFIG_BUS_WIDTH_SPI)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Send a request to a device.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_CALL_REQUEST_FUNC
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDDEVICE_CALL_REQUEST_FUNC(PSDDEVICE pDevice, PSDREQUEST pRequest)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+ @input: pRequest - the request to be sent
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Sends a request to the specified device. If the request is successfully sent, then
|
|
|
|
|
|
+ the response flags can be checked to detemine the result of the request.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of sending a request to a device:
|
|
|
|
|
|
+ PSDREQUEST pReq = NULL;
|
|
|
|
|
|
+ //allocate a request
|
|
|
|
|
|
+ pReq = SDDeviceAllocRequest(pDevice);
|
|
|
|
|
|
+ if (NULL == pReq) {
|
|
|
|
|
|
+ return SDIO_STATUS_NO_RESOURCES;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ //initialize the request
|
|
|
|
|
|
+ SDLIB_SetupCMD52Request(FuncNo, Address, Write, *pData, pReq);
|
|
|
|
|
|
+ //send the request to the target
|
|
|
|
|
|
+ status = SDDEVICE_CALL_REQUEST_FUNC(pDevice,pReq);
|
|
|
|
|
|
+ if (!SDIO_SUCCESS(status)) {
|
|
|
|
|
|
+ break;
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ //check the request response (based on the request type)
|
|
|
|
|
|
+ if (SD_R5_GET_RESP_FLAGS(pReq->Response) & SD_R5_ERRORS) {
|
|
|
|
|
|
+ ...
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ if (!Write) {
|
|
|
|
|
|
+ // store the byte
|
|
|
|
|
|
+ *pData = SD_R5_GET_READ_DATA(pReq->Response);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ //free the request
|
|
|
|
|
|
+ SDDeviceFreeRequest(pDevice,pReq);
|
|
|
|
|
|
+ ...
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDeviceAllocRequest
|
|
|
|
|
|
+ @see also: SDDEVICE_CALL_CONFIG_FUNC
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_CALL_REQUEST_FUNC(pDev,pReq) (pDev)->pRequest((pDev),(pReq))
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Send configuration to a device.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_CALL_CONFIG_FUNC
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDDEVICE_CALL_CONFIG_FUNC(PSDDEVICE pDevice, PSDCONFIG pConfigure)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+ @input: pConfigure - configuration request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Sends a configuration request to the specified device.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Example of sending a request to a device:
|
|
|
|
|
|
+ SDCONFIG configHdr;
|
|
|
|
|
|
+ SDCONFIG_FUNC_ENABLE_DISABLE_DATA fData;
|
|
|
|
|
|
+ fData.EnableFlags = SDCONFIG_ENABLE_FUNC;
|
|
|
|
|
|
+ fData.TimeOut = 500;
|
|
|
|
|
|
+ SET_SDCONFIG_CMD_INFO(&configHdr, SDCONFIG_FUNC_ENABLE_DISABLE, fData, sizeof(fData));
|
|
|
|
|
|
+ return SDDEVICE_CALL_CONFIG_FUNC(pDevice, &configHdr);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_IssueConfig
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_CALL_CONFIG_FUNC(pDev,pCfg) (pDev)->pConfigure((pDev),(pCfg))
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Allocate a request structure.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDeviceAllocRequest
|
|
|
|
|
|
+ @prototype: PSDREQUEST SDDeviceAllocRequest(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: request pointer or NULL if not available.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This function must not be called in a non-schedulable (interrupts off) context.
|
|
|
|
|
|
+ Allocating memory on some OSes may block.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_CALL_REQUEST_FUNC
|
|
|
|
|
|
+ @see also: SDDeviceFreeRequest
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDeviceAllocRequest(pDev) (pDev)->AllocRequest((pDev))
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Free a request structure.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDeviceFreeRequest
|
|
|
|
|
|
+ @prototype: void SDDeviceFreeRequest(PSDDEVICE pDevice, PSDREQUEST pRequest)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+ @input: pRequest - request allocated by SDDeviceAllocRequest().
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This function must not be called in a non-schedulable (interrupts off) context.
|
|
|
|
|
|
+ Freeing memory on some OSes may block.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_CALL_REQUEST_FUNC
|
|
|
|
|
|
+ @see also: SDDeviceAllocRequest
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDeviceFreeRequest(pDev,pReq) (pDev)->FreeRequest((pDev),pReq)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Register an interrupt handler for a device.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_SET_IRQ_HANDLER
|
|
|
|
|
|
+ @prototype: void SDDEVICE_SET_IRQ_HANDLER(PSDDEVICE pDevice,
|
|
|
|
|
|
+ void (*pIrqFunction)(PVOID pContext),
|
|
|
|
|
|
+ PVOID pContext)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+ @input: pIrqFunction - the interrupt function to execute.
|
|
|
|
|
|
+ @input: pContext - context value passed into interrupt routine.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: The registered routine will be called upon each card interrupt.
|
|
|
|
|
|
+ The interrupt function should acknowledge the interrupt when it is
|
|
|
|
|
|
+ ready to handle more interrupts using:
|
|
|
|
|
|
+ SDLIB_IssueConfig(pDevice, SDCONFIG_FUNC_ACK_IRQ, NULL, 0);
|
|
|
|
|
|
+ The interrupt handler can perform synchronous request calls.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_SET_ASYNC_IRQ_HANDLER
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_SET_IRQ_HANDLER(pDev,pFn,pContext) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ (pDev)->pIrqFunction = (pFn); \
|
|
|
|
|
|
+ (pDev)->IrqContext = (PVOID)(pContext); \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Register an asynchronous interrupt handler for a device.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_SET_ASYNC_IRQ_HANDLER
|
|
|
|
|
|
+ @prototype: void SDDEVICE_SET_ASYNC_IRQ_HANDLER(PSDDEVICE pDevice,
|
|
|
|
|
|
+ void (*pIrqAsyncFunction)(PVOID pContext),
|
|
|
|
|
|
+ PVOID pContext)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+ @input: pIrqAsyncFunction - the interrupt function to execute.
|
|
|
|
|
|
+ @input: pContext - context value passed into interrupt routine.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: The registered routine will be called upon each card interrupt.
|
|
|
|
|
|
+ The interrupt function should acknowledge the interrupt when it is
|
|
|
|
|
|
+ ready to handle more interrupts using:
|
|
|
|
|
|
+ SDLIB_IssueConfig(pDevice, SDCONFIG_FUNC_ACK_IRQ, NULL, 0);
|
|
|
|
|
|
+ The interrupt handler can not perform any synchronous request calls.
|
|
|
|
|
|
+ Using this call provides a faster interrupt dispatch, but limits all
|
|
|
|
|
|
+ requests to asynchronous mode.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_SET_IRQ_HANDLER
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_SET_ASYNC_IRQ_HANDLER(pDev,pFn,pContext) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ (pDev)->pIrqAsyncFunction = (pFn); \
|
|
|
|
|
|
+ (pDev)->IrqAsyncContext = (PVOID)(pContext); \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the SDIO capabilities rgeister.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_SDIOCARD_CAPS
|
|
|
|
|
|
+ @prototype: UINT8 SDDEVICE_GET_SDIOCARD_CAPS(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SD capabilities
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: See SD specification for decoding of these capabilities.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDDEVICE_GET_SDIO_CARD_CAPS
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_SDIOCARD_CAPS(pDev) (pDev)->pHcd->CardProperties.SDIOCaps
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get HCD driver name
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_HCDNAME
|
|
|
|
|
|
+ @prototype: PTEXT SDDEVICE_GET_HCDNAME(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the target device for this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: pointer to a string containing the name of the underlying HCD
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_HCDNAME(pDev) (pDev)->pHcd->pName
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDDEVICE_CALL_IRQ_HANDLER(pDev) (pDev)->pIrqFunction((pDev)->IrqContext)
|
|
|
|
|
|
+#define SDDEVICE_CALL_IRQ_ASYNC_HANDLER(pDev) (pDev)->pIrqAsyncFunction((pDev)->IrqAsyncContext)
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDDEVICE_SET_SDIO_FUNCNO(pDev,Num) (pDev)->pId[0].SDIO_FunctionNo = (Num)
|
|
|
|
|
|
+#define SDDEVICE_IS_CARD_REMOVED(pDev) ((pDev)->pHcd->CardProperties.CardState & \
|
|
|
|
|
|
+ CARD_STATE_REMOVED)
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef enum _SDHCD_IRQ_PROC_STATE {
|
|
|
|
|
|
+ SDHCD_IDLE = 0,
|
|
|
|
|
|
+ SDHCD_IRQ_PENDING = 1,
|
|
|
|
|
|
+ SDHCD_IRQ_HELPER = 2
|
|
|
|
|
|
+}SDHCD_IRQ_PROC_STATE, *PSDHCD_IRQ_PROC_STATE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* host controller bus driver registration structure */
|
|
|
|
|
|
+typedef struct _SDHCD {
|
|
|
|
|
|
+ CT_VERSION_CODE Version; /* version code of the SDIO stack */
|
|
|
|
|
|
+ SDLIST SDList; /* internal use list*/
|
|
|
|
|
|
+ PTEXT pName; /* name of registering host/slot driver */
|
|
|
|
|
|
+ UINT32 Attributes; /* attributes of host controller */
|
|
|
|
|
|
+ UINT16 MaxBytesPerBlock; /* max bytes per block */
|
|
|
|
|
|
+ UINT16 MaxBlocksPerTrans; /* max blocks per transaction */
|
|
|
|
|
|
+ SD_SLOT_CURRENT MaxSlotCurrent; /* max current per slot in milli-amps */
|
|
|
|
|
|
+ UINT8 SlotNumber; /* sequential slot number for this HCD, set by bus driver */
|
|
|
|
|
|
+ SD_BUSCLOCK_RATE MaxClockRate; /* max clock rate in hz */
|
|
|
|
|
|
+ SLOT_VOLTAGE_MASK SlotVoltageCaps; /* slot voltage capabilities */
|
|
|
|
|
|
+ SLOT_VOLTAGE_MASK SlotVoltagePreferred; /* preferred slot voltage */
|
|
|
|
|
|
+ PVOID pContext; /* host controller driver use data */
|
|
|
|
|
|
+ SDIO_STATUS (*pRequest)(struct _SDHCD *pHcd);
|
|
|
|
|
|
+ /* get/set configuration */
|
|
|
|
|
|
+ SDIO_STATUS (*pConfigure)(struct _SDHCD *pHcd, PSDCONFIG pConfig);
|
|
|
|
|
|
+ /* everything below this line is for bus driver use */
|
|
|
|
|
|
+ OS_SEMAPHORE ConfigureOpsSem; /* semaphore to make specific configure ops atomic, internal use */
|
|
|
|
|
|
+ OS_CRITICALSECTION HcdCritSection; /* critical section to protect hcd data structures (internal use) */
|
|
|
|
|
|
+ SDREQUESTQUEUE RequestQueue; /* request queue, internal use */
|
|
|
|
|
|
+ PSDREQUEST pCurrentRequest; /* current request we are working on */
|
|
|
|
|
|
+ CARD_PROPERTIES CardProperties; /* properties for the currently inserted card*/
|
|
|
|
|
|
+ OSKERNEL_HELPER SDIOIrqHelper; /* synch IRQ helper, internal use */
|
|
|
|
|
|
+ SDDEVICE *pPseudoDev; /* pseudo device used for initialization (internal use) */
|
|
|
|
|
|
+ UINT8 PendingHelperIrqs; /* IRQ helper pending IRQs */
|
|
|
|
|
|
+ UINT8 PendingIrqAcks; /* pending IRQ acks from function drivers */
|
|
|
|
|
|
+ UINT8 IrqsEnabled; /* current irq enabled mask */
|
|
|
|
|
|
+ SDHCD_IRQ_PROC_STATE IrqProcState; /* irq processing state */
|
|
|
|
|
|
+ POS_DEVICE pDevice; /* device registration with base system */
|
|
|
|
|
|
+ SD_SLOT_CURRENT SlotCurrentAllocated; /* slot current allocated (internal use ) */
|
|
|
|
|
|
+ ATOMIC_FLAGS HcdFlags; /* HCD Flags */
|
|
|
|
|
|
+#define HCD_REQUEST_CALL_BIT 0
|
|
|
|
|
|
+#define HCD_IRQ_NO_PEND_CHECK 1 /* HCD flag to bypass interrupt pending register
|
|
|
|
|
|
+ check, typically done on single function cards */
|
|
|
|
|
|
+ SDREQUESTQUEUE CompletedRequestQueue; /* completed request queue, internal use */
|
|
|
|
|
|
+ PSDDMA_DESCRIPTION pDmaDescription; /* description of HCD's DMA capabilities */
|
|
|
|
|
|
+ POS_MODULE pModule; /* OS-specific module information */
|
|
|
|
|
|
+ INT Recursion; /* recursion level */
|
|
|
|
|
|
+ PVOID Reserved1;
|
|
|
|
|
|
+ PVOID Reserved2;
|
|
|
|
|
|
+}SDHCD, *PSDHCD;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get a pointer to the HCD's DMA description
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDGET_DMA_DESCRIPTION
|
|
|
|
|
|
+ @prototype: PSDDMA_DESCRIPTION SDGET_DMA_DESCRIPTION(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - device structure
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: PSDDMA_DESCRIPTION or NULL if no DMA support
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: getting the current request:
|
|
|
|
|
|
+ PSDDMA_DESCRIPTION pDmaDescrp = SDGET_DMA_DESCRIPTION(pDevice);
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDGET_DMA_DESCRIPTION(pDevice) (pDevice)->pHcd->pDmaDescription
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get the logical slot number the device is assigned to.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDDEVICE_GET_SLOT_NUMBER
|
|
|
|
|
|
+ @prototype: UINT8 SDDEVICE_GET_SLOT_NUMBER(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - device structure
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: unsigned number representing the slot number
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. This value is unique for each physical slot in the system
|
|
|
|
|
|
+ and assigned by the bus driver. Devices on a multi-function card will share the same
|
|
|
|
|
|
+ slot number.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: getting the slot number:
|
|
|
|
|
|
+ UINT8 thisSlot = SDDEVICE_GET_SLOT_NUMBER(pDevice);
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDDEVICE_GET_SLOT_NUMBER(pDevice) (pDevice)->pHcd->SlotNumber
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* for function use */
|
|
|
|
|
|
+SDIO_STATUS SDIO_RegisterFunction(PSDFUNCTION pFunction);
|
|
|
|
|
|
+SDIO_STATUS SDIO_UnregisterFunction(PSDFUNCTION pFunction);
|
|
|
|
|
|
+
|
|
|
|
|
|
+#include "sdio_hcd_defs.h"
|
|
|
|
|
|
+#endif /* __SDIO_BUSDRIVER_H___ */
|
|
|
|
|
|
diff --git a/include/linux/sdio/sdio_hcd_defs.h b/include/linux/sdio/sdio_hcd_defs.h
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..1782469
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/include/linux/sdio/sdio_hcd_defs.h
|
|
|
|
|
|
@@ -0,0 +1,219 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: sdio_hcd_defs.h
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: host controller driver definitions
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2005-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#ifndef __SDIO_HCD_DEFS_H___
|
|
|
|
|
|
+#define __SDIO_HCD_DEFS_H___
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* write protect switch position data */
|
|
|
|
|
|
+typedef UINT8 SDCONFIG_WP_VALUE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* HC commands */
|
|
|
|
|
|
+#define SDCONFIG_SEND_INIT_CLOCKS (SDCONFIG_FLAGS_HC_CONFIG | SDCONFIG_FLAGS_DATA_PUT | 1)
|
|
|
|
|
|
+#define SDCONFIG_SDIO_INT_CTRL (SDCONFIG_FLAGS_HC_CONFIG | SDCONFIG_FLAGS_DATA_PUT | 2)
|
|
|
|
|
|
+#define SDCONFIG_SDIO_REARM_INT (SDCONFIG_FLAGS_HC_CONFIG | SDCONFIG_FLAGS_DATA_NONE | 3)
|
|
|
|
|
|
+#define SDCONFIG_BUS_MODE_CTRL (SDCONFIG_FLAGS_HC_CONFIG | SDCONFIG_FLAGS_DATA_BOTH | 4)
|
|
|
|
|
|
+#define SDCONFIG_POWER_CTRL (SDCONFIG_FLAGS_HC_CONFIG | SDCONFIG_FLAGS_DATA_PUT | 5)
|
|
|
|
|
|
+#define SDCONFIG_GET_WP (SDCONFIG_FLAGS_HC_CONFIG | SDCONFIG_FLAGS_DATA_GET | 6)
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* slot init clocks control */
|
|
|
|
|
|
+typedef struct _SDCONFIG_INIT_CLOCKS_DATA {
|
|
|
|
|
|
+ UINT16 NumberOfClocks; /* number of clocks to issue in the current bus mode*/
|
|
|
|
|
|
+}SDCONFIG_INIT_CLOCKS_DATA, *PSDCONFIG_INIT_CLOCKS_DATA;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* slot power control */
|
|
|
|
|
|
+typedef struct _SDCONFIG_POWER_CTRL_DATA {
|
|
|
|
|
|
+ BOOL SlotPowerEnable; /* turn on/off slot power */
|
|
|
|
|
|
+ SLOT_VOLTAGE_MASK SlotPowerVoltageMask; /* slot power voltage mask */
|
|
|
|
|
|
+}SDCONFIG_POWER_CTRL_DATA, *PSDCONFIG_POWER_CTRL_DATA;
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef UINT8 SDIO_IRQ_MODE_FLAGS;
|
|
|
|
|
|
+/* SDIO Interrupt control */
|
|
|
|
|
|
+typedef struct _SDCONFIG_SDIO_INT_CTRL_DATA {
|
|
|
|
|
|
+ BOOL SlotIRQEnable; /* turn on/off Slot IRQ detection */
|
|
|
|
|
|
+ SDIO_IRQ_MODE_FLAGS IRQDetectMode; /* slot IRQ detect mode , only valid if Enabled = TRUE */
|
|
|
|
|
|
+#define IRQ_DETECT_RAW 0x00
|
|
|
|
|
|
+#define IRQ_DETECT_MULTI_BLK 0x01
|
|
|
|
|
|
+#define IRQ_DETECT_4_BIT 0x02
|
|
|
|
|
|
+#define IRQ_DETECT_1_BIT 0x04
|
|
|
|
|
|
+#define IRQ_DETECT_SPI 0x08
|
|
|
|
|
|
+}SDCONFIG_SDIO_INT_CTRL_DATA, *PSDCONFIG_SDIO_INT_CTRL_DATA;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* card insert */
|
|
|
|
|
|
+#define EVENT_HCD_ATTACH 1
|
|
|
|
|
|
+/* card remove */
|
|
|
|
|
|
+#define EVENT_HCD_DETACH 2
|
|
|
|
|
|
+/* card slot interrupt */
|
|
|
|
|
|
+#define EVENT_HCD_SDIO_IRQ_PENDING 3
|
|
|
|
|
|
+/* transfer done */
|
|
|
|
|
|
+#define EVENT_HCD_TRANSFER_DONE 4
|
|
|
|
|
|
+/* (internal use only) */
|
|
|
|
|
|
+#define EVENT_HCD_CD_POLLING 5
|
|
|
|
|
|
+/* NOP */
|
|
|
|
|
|
+#define EVENT_HCD_NOP 0
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* attrib_flags */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_SUPPORTS_POWER 0x0001 /* host controller driver supports power managment */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_BUS_1BIT 0x0002 /* SD Native 1 - bit mode */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_BUS_4BIT 0x0004 /* SD Native 4 - bit mode */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_BUS_SPI 0x0008 /* SPI mode capable */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_READ_WAIT 0x0010 /* read wait supported (SD-only) */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_MULTI_BLK_IRQ 0x0020 /* interrupts between multi-block capable (SD-only) */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_BUS_MMC8BIT 0x0040 /* MMC 8-bit */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_SLOT_POLLING 0x0080 /* requires slot polling for Card Detect */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_POWER_SWITCH 0x0100 /* host has power switch control, must be set if SPI
|
|
|
|
|
|
+ mode can be switched to 1 or 4 bit mode */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_NO_SPI_CRC 0x0200 /* when in SPI mode,
|
|
|
|
|
|
+ host wants to run without SPI CRC */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_AUTO_CMD12 0x0400 /* host controller supports auto CMD12 */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_NO_4BIT_IRQ 0x0800 /* host controller does not support 4 bit IRQ mode*/
|
|
|
|
|
|
+#define SDHCD_ATTRIB_RAW_MODE 0x1000 /* host controller is a raw mode hcd*/
|
|
|
|
|
|
+#define SDHCD_ATTRIB_SD_HIGH_SPEED 0x2000 /* host controller supports SD high speed interface */
|
|
|
|
|
|
+#define SDHCD_ATTRIB_MMC_HIGH_SPEED 0x4000 /* host controller supports MMC high speed interface */
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define IS_CARD_PRESENT(pHcd) ((pHcd)->CardProperties.Flags & CARD_TYPE_MASK)
|
|
|
|
|
|
+#define SET_CURRENT_REQUEST(pHcd,Req) (pHcd)->pCurrentRequest = (Req)
|
|
|
|
|
|
+#define IS_HCD_RAW(pHcd) ((pHcd)->Attributes & SDHCD_ATTRIB_RAW_MODE)
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get a pointer to the current bus request for a host controller
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: GET_CURRENT_REQUEST
|
|
|
|
|
|
+ @prototype: PSDREQUEST GET_CURRENT_REQUEST (PSDHCD pHcd)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pHcd - host structure
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: current SD/SDIO bus request being worked on
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. This macro returns the current SD request that is
|
|
|
|
|
|
+ being worked on.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: getting the current request:
|
|
|
|
|
|
+ pReq = GET_CURRENT_REQUEST(&pHct->Hcd);
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define GET_CURRENT_REQUEST(pHcd) (pHcd)->pCurrentRequest
|
|
|
|
|
|
+#define GET_CURRENT_BUS_WIDTH(pHcd) SDCONFIG_GET_BUSWIDTH((pHcd)->CardProperties.BusMode)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Get host controller's current operational bus clock
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDHCD_GET_OPER_CLOCK
|
|
|
|
|
|
+ @prototype: SD_BUSCLOCK_RATE SDHCD_GET_OPER_CLOCK(PSDHCD pHcd)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pHcd - the registered host structure
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @output: none
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: clock rate
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. Returns the current bus clock rate.
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDHCD_GET_OPER_CLOCK(pHcd) (pHcd)->CardProperties.OperBusClock
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Is host controller operating in SPI mode
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: IS_HCD_BUS_MODE_SPI
|
|
|
|
|
|
+ @prototype: BOOL IS_HCD_BUS_MODE_SPI (PSDHCD pHcd)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pHcd - host structure
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: TRUE if in SPI mode
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. Host controllers that operate in SPI mode
|
|
|
|
|
|
+ dynamically can use this macro to check for SPI operation.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: testing for SPI mode:
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI(&pHct->Hcd)) {
|
|
|
|
|
|
+ .. in spi mode
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define IS_HCD_BUS_MODE_SPI(pHcd) (GET_CURRENT_BUS_WIDTH(pHcd) == SDCONFIG_BUS_WIDTH_SPI)
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Is host controller using SPI in non-CRC mode
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: IS_HCD_BUS_MODE_SPI_NO_CRC
|
|
|
|
|
|
+ @prototype: BOOL IS_HCD_BUS_MODE_SPI_NO_CRC(PSDHCD pHcd)
|
|
|
|
|
|
+ @category: HD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pHcd - host structure
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: TRUE if CRC mode is off
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: Implemented as a macro. SPI-capable cards and systems can operate in
|
|
|
|
|
|
+ non-CRC protected mode. In this mode the host controller should ignore
|
|
|
|
|
|
+ CRC fields and/or disable CRC generation when issuing command or data
|
|
|
|
|
|
+ packets. This option is useful for software based SPI mode where CRC
|
|
|
|
|
|
+ should be turned off in order to reduce processing overhead.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: test for non-CRC SPI mode:
|
|
|
|
|
|
+ if (IS_HCD_BUS_MODE_SPI_NO_CRC(&pHct->Hcd)) {
|
|
|
|
|
|
+ .. disable CRC checking in hardware.
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define IS_HCD_BUS_MODE_SPI_NO_CRC(pHcd) ((pHcd)->CardProperties.BusMode & \
|
|
|
|
|
|
+ SDCONFIG_BUS_MODE_SPI_NO_CRC)
|
|
|
|
|
|
+
|
|
|
|
|
|
+typedef UINT8 SDHCD_RESPONSE_CHECK_MODE;
|
|
|
|
|
|
+/* have SDIO core check the response token and see if it is okay to continue with
|
|
|
|
|
|
+ * the data portion */
|
|
|
|
|
|
+#define SDHCD_CHECK_DATA_TRANS_OK 0x01
|
|
|
|
|
|
+/* have SDIO core check the SPI token received */
|
|
|
|
|
|
+#define SDHCD_CHECK_SPI_TOKEN 0x02
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* prototypes */
|
|
|
|
|
|
+/* for HCD use */
|
|
|
|
|
|
+SDIO_STATUS SDIO_RegisterHostController(PSDHCD pHcd);
|
|
|
|
|
|
+SDIO_STATUS SDIO_UnregisterHostController(PSDHCD pHcd);
|
|
|
|
|
|
+SDIO_STATUS SDIO_HandleHcdEvent(PSDHCD pHcd, HCD_EVENT Event);
|
|
|
|
|
|
+SDIO_STATUS SDIO_CheckResponse(PSDHCD pHcd, PSDREQUEST pReq, SDHCD_RESPONSE_CHECK_MODE CheckMode);
|
|
|
|
|
|
+SDIO_STATUS SDIO_BusAddOSDevice(PSDDMA_DESCRIPTION pDma, POS_PNPDRIVER pDriver, POS_PNPDEVICE pDevice);
|
|
|
|
|
|
+void SDIO_BusRemoveOSDevice(POS_PNPDRIVER pDriver, POS_PNPDEVICE pDevice);
|
|
|
|
|
|
+
|
|
|
|
|
|
+#endif /* __SDIO_BUSDRIVER_H___ */
|
|
|
|
|
|
diff --git a/include/linux/sdio/sdio_lib.h b/include/linux/sdio/sdio_lib.h
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..ac0cbd7
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/include/linux/sdio/sdio_lib.h
|
|
|
|
|
|
@@ -0,0 +1,270 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: sdio_lib.h
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: SDIO Library include
|
|
|
|
|
|
+
|
|
|
|
|
|
+#notes:
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#ifndef __SDIO_LIB_H___
|
|
|
|
|
|
+#define __SDIO_LIB_H___
|
|
|
|
|
|
+
|
|
|
|
|
|
+#ifdef UNDER_CE
|
|
|
|
|
|
+#include "wince\sdio_lib_wince.h"
|
|
|
|
|
|
+#endif /* WINCE */
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define CMD52_DO_READ FALSE
|
|
|
|
|
|
+#define CMD52_DO_WRITE TRUE
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* read/write macros to any function */
|
|
|
|
|
|
+#define Cmd52WriteByteFunc(pDev,Func,Address,pValue) \
|
|
|
|
|
|
+ SDLIB_IssueCMD52((pDev),(Func),(Address),(pValue),1,CMD52_DO_WRITE)
|
|
|
|
|
|
+#define Cmd52ReadByteFunc(pDev,Func,Address,pValue) \
|
|
|
|
|
|
+ SDLIB_IssueCMD52((pDev),(Func),(Address),pValue,1,CMD52_DO_READ)
|
|
|
|
|
|
+#define Cmd52ReadMultipleFunc(pDev,Func, Address, pBuf,length) \
|
|
|
|
|
|
+ SDLIB_IssueCMD52((pDev),(Func),(Address),(pBuf),(length),CMD52_DO_READ)
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* macros to access common registers */
|
|
|
|
|
|
+#define Cmd52WriteByteCommon(pDev, Address, pValue) \
|
|
|
|
|
|
+ Cmd52WriteByteFunc((pDev),0,(Address),(pValue))
|
|
|
|
|
|
+#define Cmd52ReadByteCommon(pDev, Address, pValue) \
|
|
|
|
|
|
+ Cmd52ReadByteFunc((pDev),0,(Address),(pValue))
|
|
|
|
|
|
+#define Cmd52ReadMultipleCommon(pDev, Address, pBuf,length) \
|
|
|
|
|
|
+ Cmd52ReadMultipleFunc((pDev),0,(Address),(pBuf),(length))
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDLIB_SetupCMD52RequestAsync(f,a,w,wd,pR) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ SDLIB_SetupCMD52Request((f),(a),(w),(wd),(pR)); \
|
|
|
|
|
|
+ (pR)->Flags |= SDREQ_FLAGS_TRANS_ASYNC; \
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* a message block */
|
|
|
|
|
|
+typedef struct _SDMESSAGE_BLOCK {
|
|
|
|
|
|
+ SDLIST SDList; /* list entry */
|
|
|
|
|
|
+ INT MessageLength; /* number of bytes in this message */
|
|
|
|
|
|
+ UINT8 MessageStart[1]; /* message start */
|
|
|
|
|
|
+}SDMESSAGE_BLOCK, *PSDMESSAGE_BLOCK;
|
|
|
|
|
|
+
|
|
|
|
|
|
+ /* message queue */
|
|
|
|
|
|
+typedef struct _SDMESSAGE_QUEUE {
|
|
|
|
|
|
+ SDLIST MessageList; /* message list */
|
|
|
|
|
|
+ OS_CRITICALSECTION MessageCritSection; /* message semaphore */
|
|
|
|
|
|
+ SDLIST FreeMessageList; /* free message list */
|
|
|
|
|
|
+ INT MaxMessageLength; /* max message block length */
|
|
|
|
|
|
+}SDMESSAGE_QUEUE, *PSDMESSAGE_QUEUE;
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* internal library prototypes that can be proxied */
|
|
|
|
|
|
+SDIO_STATUS _SDLIB_IssueCMD52(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT8 FuncNo,
|
|
|
|
|
|
+ UINT32 Address,
|
|
|
|
|
|
+ PUINT8 pData,
|
|
|
|
|
|
+ INT ByteCount,
|
|
|
|
|
|
+ BOOL Write);
|
|
|
|
|
|
+SDIO_STATUS _SDLIB_FindTuple(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT8 Tuple,
|
|
|
|
|
|
+ UINT32 *pTupleScanAddress,
|
|
|
|
|
|
+ PUINT8 pBuffer,
|
|
|
|
|
|
+ UINT8 *pLength);
|
|
|
|
|
|
+SDIO_STATUS _SDLIB_IssueConfig(PSDDEVICE pDevice,
|
|
|
|
|
|
+ SDCONFIG_COMMAND Command,
|
|
|
|
|
|
+ PVOID pData,
|
|
|
|
|
|
+ INT Length);
|
|
|
|
|
|
+void _SDLIB_PrintBuffer(PUCHAR pBuffer, INT Length,PTEXT pDescription);
|
|
|
|
|
|
+void _SDLIB_SetupCMD52Request(UINT8 FuncNo,
|
|
|
|
|
|
+ UINT32 Address,
|
|
|
|
|
|
+ BOOL Write,
|
|
|
|
|
|
+ UINT8 WriteData,
|
|
|
|
|
|
+ PSDREQUEST pRequest);
|
|
|
|
|
|
+SDIO_STATUS _SDLIB_SetFunctionBlockSize(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT16 BlockSize);
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS _SDLIB_GetDefaultOpCurrent(PSDDEVICE pDevice,
|
|
|
|
|
|
+ SD_SLOT_CURRENT *pOpCurrent);
|
|
|
|
|
|
+PSDMESSAGE_QUEUE _CreateMessageQueue(INT MaxMessages, INT MaxMessageLength);
|
|
|
|
|
|
+void _DeleteMessageQueue(PSDMESSAGE_QUEUE pQueue);
|
|
|
|
|
|
+SDIO_STATUS _PostMessage(PSDMESSAGE_QUEUE pQueue, PVOID pMessage, INT MessageLength);
|
|
|
|
|
|
+SDIO_STATUS _GetMessage(PSDMESSAGE_QUEUE pQueue, PVOID pData, INT *pBufferLength);
|
|
|
|
|
|
+
|
|
|
|
|
|
+#ifdef CTSYSTEM_NO_FUNCTION_PROXIES
|
|
|
|
|
|
+ /* OS port requires no proxy functions, use methods directly from the library */
|
|
|
|
|
|
+#define SDLIB_IssueCMD52 _SDLIB_IssueCMD52
|
|
|
|
|
|
+#define SDLIB_SetupCMD52Request _SDLIB_SetupCMD52Request
|
|
|
|
|
|
+#define SDLIB_FindTuple _SDLIB_FindTuple
|
|
|
|
|
|
+#define SDLIB_IssueConfig _SDLIB_IssueConfig
|
|
|
|
|
|
+#define SDLIB_SetFunctionBlockSize _SDLIB_SetFunctionBlockSize
|
|
|
|
|
|
+#define SDLIB_GetDefaultOpCurrent _SDLIB_GetDefaultOpCurrent
|
|
|
|
|
|
+#define SDLIB_CreateMessageQueue _CreateMessageQueue
|
|
|
|
|
|
+#define SDLIB_DeleteMessageQueue _DeleteMessageQueue
|
|
|
|
|
|
+#define SDLIB_PostMessage _PostMessage
|
|
|
|
|
|
+#define SDLIB_GetMessage _GetMessage
|
|
|
|
|
|
+#define SDLIB_PrintBuffer _SDLIB_PrintBuffer
|
|
|
|
|
|
+#else
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* proxied versions */
|
|
|
|
|
|
+SDIO_STATUS SDLIB_IssueCMD52(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT8 FuncNo,
|
|
|
|
|
|
+ UINT32 Address,
|
|
|
|
|
|
+ PUINT8 pData,
|
|
|
|
|
|
+ INT ByteCount,
|
|
|
|
|
|
+ BOOL Write);
|
|
|
|
|
|
+
|
|
|
|
|
|
+void SDLIB_SetupCMD52Request(UINT8 FuncNo,
|
|
|
|
|
|
+ UINT32 Address,
|
|
|
|
|
|
+ BOOL Write,
|
|
|
|
|
|
+ UINT8 WriteData,
|
|
|
|
|
|
+ PSDREQUEST pRequest);
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_FindTuple(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT8 Tuple,
|
|
|
|
|
|
+ UINT32 *pTupleScanAddress,
|
|
|
|
|
|
+ PUINT8 pBuffer,
|
|
|
|
|
|
+ UINT8 *pLength);
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_IssueConfig(PSDDEVICE pDevice,
|
|
|
|
|
|
+ SDCONFIG_COMMAND Command,
|
|
|
|
|
|
+ PVOID pData,
|
|
|
|
|
|
+ INT Length);
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_SetFunctionBlockSize(PSDDEVICE pDevice,
|
|
|
|
|
|
+ UINT16 BlockSize);
|
|
|
|
|
|
+
|
|
|
|
|
|
+void SDLIB_PrintBuffer(PUCHAR pBuffer, INT Length,PTEXT pDescription);
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_GetDefaultOpCurrent(PSDDEVICE pDevice, SD_SLOT_CURRENT *pOpCurrent);
|
|
|
|
|
|
+
|
|
|
|
|
|
+PSDMESSAGE_QUEUE SDLIB_CreateMessageQueue(INT MaxMessages, INT MaxMessageLength);
|
|
|
|
|
|
+
|
|
|
|
|
|
+void SDLIB_DeleteMessageQueue(PSDMESSAGE_QUEUE pQueue);
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_PostMessage(PSDMESSAGE_QUEUE pQueue, PVOID pMessage, INT MessageLength);
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_GetMessage(PSDMESSAGE_QUEUE pQueue, PVOID pData, INT *pBufferLength);
|
|
|
|
|
|
+#endif /* CTSYSTEM_NO_FUNCTION_PROXIES */
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+SDIO_STATUS SDLIB_OSCreateHelper(POSKERNEL_HELPER pHelper,
|
|
|
|
|
|
+ PHELPER_FUNCTION pFunction,
|
|
|
|
|
|
+ PVOID pContext);
|
|
|
|
|
|
+
|
|
|
|
|
|
+void SDLIB_OSDeleteHelper(POSKERNEL_HELPER pHelper);
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Check message queue is empty
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_IsQueueEmpty
|
|
|
|
|
|
+ @prototype: BOOL SDLIB_IsQueueEmpty(PSDMESSAGE_QUEUE pQueue)
|
|
|
|
|
|
+ @category: Support_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pQueue - message queue to check
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: TRUE if empty else false
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_CreateMessageQueue
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Check message queue :
|
|
|
|
|
|
+ if (SDLIB_IsQueueEmpty(pInstance->pQueue)) {
|
|
|
|
|
|
+ .. message queue is empty
|
|
|
|
|
|
+ }
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static INLINE BOOL SDLIB_IsQueueEmpty(PSDMESSAGE_QUEUE pQueue) {
|
|
|
|
|
|
+ return SDLIST_IS_EMPTY(&pQueue->MessageList);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Issue an I/O abort request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_IssueIOAbort
|
|
|
|
|
|
+ @prototype: SDIO_STATUS SDLIB_IssueIOAbort(PSDDEVICE pDevice)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the device that is the target of this request
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @return: SDIO_STATUS
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @notes: This procedure can be called to issue an I/O abort request to an I/O function.
|
|
|
|
|
|
+ This procedure cannot be used to abort a data (block) transfer already in progress.
|
|
|
|
|
|
+ It is intended to be used when a data (block) transfer completes with an error and only if
|
|
|
|
|
|
+ the I/O function requires an abort action. Some I/O functions may automatically
|
|
|
|
|
|
+ recover from such failures and not require this action. This function issues
|
|
|
|
|
|
+ the abort command synchronously and can potentially block.
|
|
|
|
|
|
+ If an async request is required, you must allocate a request and use
|
|
|
|
|
|
+ SDLIB_SetupIOAbortAsync() to prepare the request.
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @example: Issuing I/O Abort synchronously :
|
|
|
|
|
|
+ .. check status from last block operation:
|
|
|
|
|
|
+ if (status == SDIO_STATUS_BUS_READ_TIMEOUT) {
|
|
|
|
|
|
+ .. on failure, issue I/O abort
|
|
|
|
|
|
+ status2 = SDLIB_IssueIOAbort(pDevice);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ Issuing I/O Abort asynchronously:
|
|
|
|
|
|
+ ... allocate a request
|
|
|
|
|
|
+ ... setup the request:
|
|
|
|
|
|
+ SDLIB_SetupIOAbortAsync(pDevice,pReq);
|
|
|
|
|
|
+ pReq->pCompletion = myIOAbortCompletion;
|
|
|
|
|
|
+ pReq->pCompleteContext = pDevice;
|
|
|
|
|
|
+ status = SDDEVICE_CALL_REQUEST_FUNC(pDevice,pReq);
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_SetupIOAbortAsync
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+static INLINE SDIO_STATUS SDLIB_IssueIOAbort(PSDDEVICE pDevice) {
|
|
|
|
|
|
+ UINT8 value = SDDEVICE_GET_SDIO_FUNCNO(pDevice);
|
|
|
|
|
|
+ return Cmd52WriteByteCommon(pDevice,0x06,&value);
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+ @function: Setup an I/O abort request for async operation
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @function name: SDLIB_SetupIOAbortAsync
|
|
|
|
|
|
+ @prototype: SDLIB_SetupIOAbortAsync(PSDDEVICE pDevice, PSDREQUEST pRequest)
|
|
|
|
|
|
+ @category: PD_Reference
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @input: pDevice - the device that is the target of this request
|
|
|
|
|
|
+ pRequest - the request to set up
|
|
|
|
|
|
+
|
|
|
|
|
|
+ @see also: SDLIB_IssueIOAbort
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#define SDLIB_SetupIOAbortAsync(pDevice, pReq) \
|
|
|
|
|
|
+ SDLIB_SetupCMD52RequestAsync(0,0x06,TRUE,SDDEVICE_GET_SDIO_FUNCNO(pDevice),(pReq))
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+#endif /* __SDIO_LIB_H___*/
|
|
|
|
|
|
diff --git a/include/linux/sdio/sdlist.h b/include/linux/sdio/sdlist.h
|
|
|
|
|
|
new file mode 100644
|
|
|
|
|
|
index 0000000..dc35e1c
|
|
|
|
|
|
--- /dev/null
|
|
|
|
|
|
+++ b/include/linux/sdio/sdlist.h
|
|
|
|
|
|
@@ -0,0 +1,141 @@
|
|
|
|
|
|
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
+@file: sdlist.h
|
|
|
|
|
|
+
|
|
|
|
|
|
+@abstract: OS independent list functions
|
|
|
|
|
|
+
|
|
|
|
|
|
+@notice: Copyright (c), 2004-2006 Atheros Communications, Inc.
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * 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;
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Software distributed under the License is distributed on an "AS
|
|
|
|
|
|
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
|
|
+ * implied. See the License for the specific language governing
|
|
|
|
|
|
+ * rights and limitations under the License.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * Portions of this code were developed with information supplied from the
|
|
|
|
|
|
+ * SD Card Association Simplified Specifications. The following conditions and disclaimers may apply:
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The following conditions apply to the release of the SD simplified specification (<28>Simplified
|
|
|
|
|
|
+ * Specification<6F>) by the SD Card Association. The Simplified Specification is a subset of the complete
|
|
|
|
|
|
+ * SD Specification which is owned by the SD Card Association. This Simplified Specification is provided
|
|
|
|
|
|
+ * on a non-confidential basis subject to the disclaimers below. Any implementation of the Simplified
|
|
|
|
|
|
+ * Specification may require a license from the SD Card Association or other third parties.
|
|
|
|
|
|
+ * Disclaimers:
|
|
|
|
|
|
+ * The information contained in the Simplified Specification is presented only as a standard
|
|
|
|
|
|
+ * specification for SD Cards and SD Host/Ancillary products and is provided "AS-IS" without any
|
|
|
|
|
|
+ * representations or warranties of any kind. No responsibility is assumed by the SD Card Association for
|
|
|
|
|
|
+ * any damages, any infringements of patents or other right of the SD Card Association or any third
|
|
|
|
|
|
+ * parties, which may result from its use. No license is granted by implication, estoppel or otherwise
|
|
|
|
|
|
+ * under any patent or other rights of the SD Card Association or any third party. Nothing herein shall
|
|
|
|
|
|
+ * be construed as an obligation by the SD Card Association to disclose or distribute any technical
|
|
|
|
|
|
+ * information, know-how or other confidential information to any third party.
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * The initial developers of the original code are Seung Yi and Paul Lever
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ * sdio@atheros.com
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+ *
|
|
|
|
|
|
+
|
|
|
|
|
|
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
|
|
|
|
|
|
+#ifndef __SDLIST_H___
|
|
|
|
|
|
+#define __SDLIST_H___
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* list functions */
|
|
|
|
|
|
+/* pointers for the list */
|
|
|
|
|
|
+typedef struct _SDLIST {
|
|
|
|
|
|
+ struct _SDLIST *pPrev;
|
|
|
|
|
|
+ struct _SDLIST *pNext;
|
|
|
|
|
|
+}SDLIST, *PSDLIST;
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * SDLIST_INIT , circular list
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+#define SDLIST_INIT(pList)\
|
|
|
|
|
|
+ {(pList)->pPrev = pList; (pList)->pNext = pList;}
|
|
|
|
|
|
+#define SDLIST_INIT_DECLARE(List)\
|
|
|
|
|
|
+ SDLIST List = {&List, &List}
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDLIST_IS_EMPTY(pList) (((pList)->pPrev == (pList)) && ((pList)->pNext == (pList)))
|
|
|
|
|
|
+#define SDLIST_GET_ITEM_AT_HEAD(pList) (pList)->pNext
|
|
|
|
|
|
+#define SDLIST_GET_ITEM_AT_TAIL(pList) (pList)->pPrev
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * SDITERATE_OVER_LIST pStart is the list, pTemp is a temp list member
|
|
|
|
|
|
+ * NOT: do not use this function if the items in the list are deleted inside the
|
|
|
|
|
|
+ * iteration loop
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+#define SDITERATE_OVER_LIST(pStart, pTemp) \
|
|
|
|
|
|
+ for((pTemp) =(pStart)->pNext; pTemp != (pStart); (pTemp) = (pTemp)->pNext)
|
|
|
|
|
|
+
|
|
|
|
|
|
+
|
|
|
|
|
|
+/* safe iterate macro that allows the item to be removed from the list
|
|
|
|
|
|
+ * the iteration continues to the next item in the list
|
|
|
|
|
|
+ */
|
|
|
|
|
|
+#define SDITERATE_OVER_LIST_ALLOW_REMOVE(pStart,pItem,st,offset) \
|
|
|
|
|
|
+{ \
|
|
|
|
|
|
+ PSDLIST pTemp; \
|
|
|
|
|
|
+ pTemp = (pStart)->pNext; \
|
|
|
|
|
|
+ while (pTemp != (pStart)) { \
|
|
|
|
|
|
+ (pItem) = CONTAINING_STRUCT(pTemp,st,offset); \
|
|
|
|
|
|
+ pTemp = pTemp->pNext; \
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDITERATE_END }}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * SDListInsertTail - insert pAdd to the end of the list
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static INLINE PSDLIST SDListInsertTail(PSDLIST pList, PSDLIST pAdd) {
|
|
|
|
|
|
+ /* this assert catches when an item is added twice */
|
|
|
|
|
|
+ DBG_ASSERT(pAdd->pNext != pList);
|
|
|
|
|
|
+ /* insert at tail */
|
|
|
|
|
|
+ pAdd->pPrev = pList->pPrev;
|
|
|
|
|
|
+ pAdd->pNext = pList;
|
|
|
|
|
|
+ pList->pPrev->pNext = pAdd;
|
|
|
|
|
|
+ pList->pPrev = pAdd;
|
|
|
|
|
|
+ return pAdd;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * SDListInsertHead - insert pAdd into the head of the list
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static INLINE PSDLIST SDListInsertHead(PSDLIST pList, PSDLIST pAdd) {
|
|
|
|
|
|
+ /* this assert catches when an item is added twice */
|
|
|
|
|
|
+ DBG_ASSERT(pAdd->pPrev != pList);
|
|
|
|
|
|
+ /* insert at head */
|
|
|
|
|
|
+ pAdd->pPrev = pList;
|
|
|
|
|
|
+ pAdd->pNext = pList->pNext;
|
|
|
|
|
|
+ pList->pNext->pPrev = pAdd;
|
|
|
|
|
|
+ pList->pNext = pAdd;
|
|
|
|
|
|
+ return pAdd;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+#define SDListAdd(pList,pItem) SDListInsertHead((pList),(pItem))
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * SDListRemove - remove pDel from list
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static INLINE PSDLIST SDListRemove(PSDLIST pDel) {
|
|
|
|
|
|
+ pDel->pNext->pPrev = pDel->pPrev;
|
|
|
|
|
|
+ pDel->pPrev->pNext = pDel->pNext;
|
|
|
|
|
|
+ /* point back to itself just to be safe, incase remove is called again */
|
|
|
|
|
|
+ pDel->pNext = pDel;
|
|
|
|
|
|
+ pDel->pPrev = pDel;
|
|
|
|
|
|
+ return pDel;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+
|
|
|
|
|
|
+/*
|
|
|
|
|
|
+ * SDListRemoveItemFromHead - get a list item from the head
|
|
|
|
|
|
+*/
|
|
|
|
|
|
+static INLINE PSDLIST SDListRemoveItemFromHead(PSDLIST pList) {
|
|
|
|
|
|
+ PSDLIST pItem = NULL;
|
|
|
|
|
|
+ if (pList->pNext != pList) {
|
|
|
|
|
|
+ pItem = pList->pNext;
|
|
|
|
|
|
+ /* remove the first item from head */
|
|
|
|
|
|
+ SDListRemove(pItem);
|
|
|
|
|
|
+ }
|
|
|
|
|
|
+ return pItem;
|
|
|
|
|
|
+}
|
|
|
|
|
|
+#endif /* __SDLIST_H___ */
|
|
|
|
|
|
--
|
2008-12-12 13:58:53 +02:00
|
|
|
|
1.5.6.5
|
2008-12-12 02:02:36 +02:00
|
|
|
|
|
