diff options
Diffstat (limited to 'target/linux/s3c24xx/patches-2.6.26/1055-atheros_2_0_sdio_stack.patch.patch')
| -rwxr-xr-x | target/linux/s3c24xx/patches-2.6.26/1055-atheros_2_0_sdio_stack.patch.patch | 13982 |
1 files changed, 0 insertions, 13982 deletions
diff --git a/target/linux/s3c24xx/patches-2.6.26/1055-atheros_2_0_sdio_stack.patch.patch b/target/linux/s3c24xx/patches-2.6.26/1055-atheros_2_0_sdio_stack.patch.patch deleted file mode 100755 index e29f050afe..0000000000 --- a/target/linux/s3c24xx/patches-2.6.26/1055-atheros_2_0_sdio_stack.patch.patch +++ /dev/null @@ -1,13982 +0,0 @@ -From 79b0634b39757c62f4e61256c12ddf8e7b3783c4 Mon Sep 17 00:00:00 2001 -From: mokopatches <mokopatches@openmoko.org> -Date: Fri, 25 Jul 2008 22:21:24 +0100 -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 -index b786e68..e394067 100644 ---- a/arch/arm/Kconfig -+++ b/arch/arm/Kconfig -@@ -1169,6 +1169,8 @@ source "drivers/hid/Kconfig" - - source "drivers/usb/Kconfig" - -+source "drivers/sdio/Kconfig" -+ - source "drivers/mmc/Kconfig" - - source "drivers/leds/Kconfig" -diff --git a/drivers/Kconfig b/drivers/Kconfig -index 59f33fa..f5900b7 100644 ---- a/drivers/Kconfig -+++ b/drivers/Kconfig -@@ -78,6 +78,8 @@ source "drivers/hid/Kconfig" - - source "drivers/usb/Kconfig" - -+source "drivers/sdio/Kconfig" -+ - source "drivers/mmc/Kconfig" - - source "drivers/memstick/Kconfig" -diff --git a/drivers/Makefile b/drivers/Makefile -index f65deda..ce63a01 100644 ---- a/drivers/Makefile -+++ b/drivers/Makefile -@@ -80,6 +80,7 @@ obj-$(CONFIG_CPU_FREQ) += cpufreq/ - obj-$(CONFIG_CPU_IDLE) += cpuidle/ - obj-$(CONFIG_MMC) += mmc/ - obj-$(CONFIG_MEMSTICK) += memstick/ -+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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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 (�Simplified -+ * Specification�) 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___ */ --- -1.5.6.3 - |