1 files changed, 1596 insertions, 0 deletions

diff --git a/drivers/net/wireless/bcm4329/bcmsdspi.c b/drivers/net/wireless/bcm4329/bcmsdspi.c
new file mode 100644
index 00000000000..636539be5ea
--- /dev/null
+++ b/drivers/net/wireless/bcm4329/bcmsdspi.c
@@ -0,0 +1,1596 @@
+/*
+ * Broadcom BCMSDH to SPI Protocol Conversion Layer
+ *
+ * Copyright (C) 1999-2010, Broadcom Corporation
+ * 
+ *      Unless you and Broadcom execute a separate written software license
+ * agreement governing use of this software, this software is licensed to you
+ * under the terms of the GNU General Public License version 2 (the "GPL"),
+ * available at http://www.broadcom.com/licenses/GPLv2.php, with the
+ * following added to such license:
+ * 
+ *      As a special exception, the copyright holders of this software give you
+ * permission to link this software with independent modules, and to copy and
+ * distribute the resulting executable under terms of your choice, provided that
+ * you also meet, for each linked independent module, the terms and conditions of
+ * the license of that module.  An independent module is a module which is not
+ * derived from this software.  The special exception does not apply to any
+ * modifications of the software.
+ * 
+ *      Notwithstanding the above, under no circumstances may you combine this
+ * software in any way with any other Broadcom software provided under a license
+ * other than the GPL, without Broadcom's express prior written consent.
+ *
+ * $Id: bcmsdspi.c,v 1.14.4.2.4.4.6.5 2010/03/10 03:09:48 Exp $
+ */
+
+#include <typedefs.h>
+
+#include <bcmdevs.h>
+#include <bcmendian.h>
+#include <bcmutils.h>
+#include <osl.h>
+#include <siutils.h>
+#include <sdio.h>               /* SDIO Device and Protocol Specs */
+#include <sdioh.h>              /* SDIO Host Controller Specification */
+#include <bcmsdbus.h>           /* bcmsdh to/from specific controller APIs */
+#include <sdiovar.h>            /* ioctl/iovars */
+
+#include <pcicfg.h>
+
+
+#include <bcmsdspi.h>
+#include <bcmspi.h>
+
+#include <proto/sdspi.h>
+
+#define SD_PAGE 4096
+
+/* Globals */
+
+uint sd_msglevel = SDH_ERROR_VAL;
+uint sd_hiok = FALSE;           /* Use hi-speed mode if available? */
+uint sd_sdmode = SDIOH_MODE_SPI;                /* Use SD4 mode by default */
+uint sd_f2_blocksize = 512;     /* Default blocksize */
+
+uint sd_divisor = 2;            /* Default 33MHz/2 = 16MHz for dongle */
+uint sd_power = 1;              /* Default to SD Slot powered ON */
+uint sd_clock = 1;              /* Default to SD Clock turned ON */
+uint sd_crc = 0;                /* Default to SPI CRC Check turned OFF */
+uint sd_pci_slot = 0xFFFFffff; /* Used to force selection of a particular PCI slot */
+
+uint sd_toctl = 7;
+
+/* Prototypes */
+static bool sdspi_start_power(sdioh_info_t *sd);
+static int sdspi_set_highspeed_mode(sdioh_info_t *sd, bool HSMode);
+static int sdspi_card_enablefuncs(sdioh_info_t *sd);
+static void sdspi_cmd_getrsp(sdioh_info_t *sd, uint32 *rsp_buffer, int count);
+static int sdspi_cmd_issue(sdioh_info_t *sd, bool use_dma, uint32 cmd, uint32 arg,
+                           uint32 *data, uint32 datalen);
+static int sdspi_card_regread(sdioh_info_t *sd, int func, uint32 regaddr,
+                              int regsize, uint32 *data);
+static int sdspi_card_regwrite(sdioh_info_t *sd, int func, uint32 regaddr,
+                               int regsize, uint32 data);
+static int sdspi_driver_init(sdioh_info_t *sd);
+static bool sdspi_reset(sdioh_info_t *sd, bool host_reset, bool client_reset);
+static int sdspi_card_buf(sdioh_info_t *sd, int rw, int func, bool fifo,
+                          uint32 addr, int nbytes, uint32 *data);
+static int sdspi_abort(sdioh_info_t *sd, uint func);
+
+static int set_client_block_size(sdioh_info_t *sd, int func, int blocksize);
+
+static uint8 sdspi_crc7(unsigned char* p, uint32 len);
+static uint16 sdspi_crc16(unsigned char* p, uint32 len);
+static int sdspi_crc_onoff(sdioh_info_t *sd, bool use_crc);
+
+/*
+ *  Public entry points & extern's
+ */
+extern sdioh_info_t *
+sdioh_attach(osl_t *osh, void *bar0, uint irq)
+{
+        sdioh_info_t *sd;
+
+        sd_trace(("%s\n", __FUNCTION__));
+        if ((sd = (sdioh_info_t *)MALLOC(osh, sizeof(sdioh_info_t))) == NULL) {
+                sd_err(("sdioh_attach: out of memory, malloced %d bytes\n", MALLOCED(osh)));
+                return NULL;
+        }
+        bzero((char *)sd, sizeof(sdioh_info_t));
+        sd->osh = osh;
+
+        if (spi_osinit(sd) != 0) {
+                sd_err(("%s: spi_osinit() failed\n", __FUNCTION__));
+                MFREE(sd->osh, sd, sizeof(sdioh_info_t));
+                return NULL;
+        }
+
+        sd->bar0 = (uintptr)bar0;
+        sd->irq = irq;
+        sd->intr_handler = NULL;
+        sd->intr_handler_arg = NULL;
+        sd->intr_handler_valid = FALSE;
+
+        /* Set defaults */
+        sd->sd_blockmode = FALSE;
+        sd->use_client_ints = TRUE;
+        sd->sd_use_dma = FALSE; /* DMA Not supported */
+
+        /* Haven't figured out how to make bytemode work with dma */
+        if (!sd->sd_blockmode)
+                sd->sd_use_dma = 0;
+
+        if (!spi_hw_attach(sd)) {
+                sd_err(("%s: spi_hw_attach() failed\n", __FUNCTION__));
+                spi_osfree(sd);
+                MFREE(sd->osh, sd, sizeof(sdioh_info_t));
+                return NULL;
+        }
+
+        if (sdspi_driver_init(sd) != SUCCESS) {
+                if (sdspi_driver_init(sd) != SUCCESS) {
+                        sd_err(("%s:sdspi_driver_init() failed()\n", __FUNCTION__));
+                        spi_hw_detach(sd);
+                        spi_osfree(sd);
+                        MFREE(sd->osh, sd, sizeof(sdioh_info_t));
+                        return (NULL);
+                }
+        }
+
+        if (spi_register_irq(sd, irq) != SUCCESS) {
+                sd_err(("%s: spi_register_irq() failed for irq = %d\n", __FUNCTION__, irq));
+                spi_hw_detach(sd);
+                spi_osfree(sd);
+                MFREE(sd->osh, sd, sizeof(sdioh_info_t));
+                return (NULL);
+        }
+
+        sd_trace(("%s: Done\n", __FUNCTION__));
+        return sd;
+}
+
+extern SDIOH_API_RC
+sdioh_detach(osl_t *osh, sdioh_info_t *sd)
+{
+        sd_trace(("%s\n", __FUNCTION__));
+
+        if (sd) {
+                if (sd->card_init_done)
+                        sdspi_reset(sd, 1, 1);
+
+                sd_info(("%s: detaching from hardware\n", __FUNCTION__));
+                spi_free_irq(sd->irq, sd);
+                spi_hw_detach(sd);
+                spi_osfree(sd);
+                MFREE(sd->osh, sd, sizeof(sdioh_info_t));
+        }
+
+        return SDIOH_API_RC_SUCCESS;
+}
+
+/* Configure callback to client when we recieve client interrupt */
+extern SDIOH_API_RC
+sdioh_interrupt_register(sdioh_info_t *sd, sdioh_cb_fn_t fn, void *argh)
+{
+        sd_trace(("%s: Entering\n", __FUNCTION__));
+
+        sd->intr_handler = fn;
+        sd->intr_handler_arg = argh;
+        sd->intr_handler_valid = TRUE;
+
+        return SDIOH_API_RC_SUCCESS;
+}
+
+extern SDIOH_API_RC
+sdioh_interrupt_deregister(sdioh_info_t *sd)
+{
+        sd_trace(("%s: Entering\n", __FUNCTION__));
+
+        sd->intr_handler_valid = FALSE;
+        sd->intr_handler = NULL;
+        sd->intr_handler_arg = NULL;
+
+        return SDIOH_API_RC_SUCCESS;
+}
+
+extern SDIOH_API_RC
+sdioh_interrupt_query(sdioh_info_t *sd, bool *onoff)
+{
+        sd_trace(("%s: Entering\n", __FUNCTION__));
+
+        *onoff = sd->client_intr_enabled;
+
+        return SDIOH_API_RC_SUCCESS;
+}
+
+#if defined(DHD_DEBUG)
+extern bool