aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/brcm80211
diff options
context:
space:
mode:
authorJohn W. Linville <linville@tuxdriver.com>2014-01-01 15:39:56 -0500
committerJohn W. Linville <linville@tuxdriver.com>2014-01-01 15:39:56 -0500
commitad86c55bac643a745f480d26689d153ec0f38b04 (patch)
tree8ae3e20d2f3619021393166fe1f50a8ca00c1c33 /drivers/net/wireless/brcm80211
parent21eb218989523b7bee28900aaec9f9296b70fa27 (diff)
parent39731b78b4afebb7501c05b68e2443a1b250b41c (diff)
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-next into for-davem
Diffstat (limited to 'drivers/net/wireless/brcm80211')
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/Makefile1
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/bcdc.c79
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c628
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/bcmsdh_sdmmc.c552
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/dhd_bus.h8
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c740
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/fwil.c12
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/fwsignal.c41
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/proto.c2
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/proto.h14
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/sdio_chip.c296
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/sdio_chip.h2
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/sdio_host.h82
-rw-r--r--drivers/net/wireless/brcm80211/brcmfmac/usb.c1
14 files changed, 1108 insertions, 1350 deletions
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/Makefile b/drivers/net/wireless/brcm80211/brcmfmac/Makefile
index 2082402d4b63..5681b9862023 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/Makefile
+++ b/drivers/net/wireless/brcm80211/brcmfmac/Makefile
@@ -36,7 +36,6 @@ brcmfmac-objs += \
36brcmfmac-$(CONFIG_BRCMFMAC_SDIO) += \ 36brcmfmac-$(CONFIG_BRCMFMAC_SDIO) += \
37 dhd_sdio.o \ 37 dhd_sdio.o \
38 bcmsdh.o \ 38 bcmsdh.o \
39 bcmsdh_sdmmc.o \
40 sdio_chip.o 39 sdio_chip.o
41brcmfmac-$(CONFIG_BRCMFMAC_USB) += \ 40brcmfmac-$(CONFIG_BRCMFMAC_USB) += \
42 usb.o 41 usb.o
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/bcdc.c b/drivers/net/wireless/brcm80211/brcmfmac/bcdc.c
index 06848e426f9a..12c27d13df7f 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/bcdc.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/bcdc.c
@@ -101,35 +101,41 @@ struct brcmf_proto_bcdc_header {
101 * plus any space that might be needed 101 * plus any space that might be needed
102 * for bus alignment padding. 102 * for bus alignment padding.
103 */ 103 */
104#define ROUND_UP_MARGIN 2048 /* Biggest bus block size possible for
105 * round off at the end of buffer
106 * Currently is SDIO
107 */
108
109struct brcmf_bcdc { 104struct brcmf_bcdc {
110 u16 reqid; 105 u16 reqid;
111 u8 bus_header[BUS_HEADER_LEN]; 106 u8 bus_header[BUS_HEADER_LEN];
112 struct brcmf_proto_bcdc_dcmd msg; 107 struct brcmf_proto_bcdc_dcmd msg;
113 unsigned char buf[BRCMF_DCMD_MAXLEN + ROUND_UP_MARGIN]; 108 unsigned char buf[BRCMF_DCMD_MAXLEN];
114}; 109};
115 110
116static int brcmf_proto_bcdc_msg(struct brcmf_pub *drvr) 111
112static int
113brcmf_proto_bcdc_msg(struct brcmf_pub *drvr, int ifidx, uint cmd, void *buf,
114 uint len, bool set)
117{ 115{
118 struct brcmf_bcdc *bcdc = (struct brcmf_bcdc *)drvr->proto->pd; 116 struct brcmf_bcdc *bcdc = (struct brcmf_bcdc *)drvr->proto->pd;
119 int len = le32_to_cpu(bcdc->msg.len) + 117 struct brcmf_proto_bcdc_dcmd *msg = &bcdc->msg;
120 sizeof(struct brcmf_proto_bcdc_dcmd); 118 u32 flags;
121 119
122 brcmf_dbg(BCDC, "Enter\n"); 120 brcmf_dbg(BCDC, "Enter\n");
123 121
124 /* NOTE : bcdc->msg.len holds the desired length of the buffer to be 122 memset(msg, 0, sizeof(struct brcmf_proto_bcdc_dcmd));
125 * returned. Only up to BCDC_MAX_MSG_SIZE of this buffer area 123
126 * is actually sent to the dongle 124 msg->cmd = cpu_to_le32(cmd);
127 */ 125 msg->len = cpu_to_le32(len);
128 if (len > BCDC_MAX_MSG_SIZE) 126 flags = (++bcdc->reqid << BCDC_DCMD_ID_SHIFT);
129 len = BCDC_MAX_MSG_SIZE; 127 if (set)
128 flags |= BCDC_DCMD_SET;
129 flags = (flags & ~BCDC_DCMD_IF_MASK) |
130 (ifidx << BCDC_DCMD_IF_SHIFT);
131 msg->flags = cpu_to_le32(flags);
132
133 if (buf)
134 memcpy(bcdc->buf, buf, len);
130 135
131 /* Send request */ 136 /* Send request */
132 return brcmf_bus_txctl(drvr->bus_if, (unsigned char *)&bcdc->msg, len); 137 return brcmf_bus_txctl(drvr->bus_if, (unsigned char *)&bcdc->msg,
138 len + sizeof(struct brcmf_proto_bcdc_dcmd));
133} 139}
134 140
135static int brcmf_proto_bcdc_cmplt(struct brcmf_pub *drvr, u32 id, u32 len) 141static int brcmf_proto_bcdc_cmplt(struct brcmf_pub *drvr, u32 id, u32 len)
@@ -161,19 +167,7 @@ brcmf_proto_bcdc_query_dcmd(struct brcmf_pub *drvr, int ifidx, uint cmd,
161 167
162 brcmf_dbg(BCDC, "Enter, cmd %d len %d\n", cmd, len); 168 brcmf_dbg(BCDC, "Enter, cmd %d len %d\n", cmd, len);
163 169
164 memset(msg, 0, sizeof(struct brcmf_proto_bcdc_dcmd)); 170 ret = brcmf_proto_bcdc_msg(drvr, ifidx, cmd, buf, len, false);
165
166 msg->cmd = cpu_to_le32(cmd);
167 msg->len = cpu_to_le32(len);
168 flags = (++bcdc->reqid << BCDC_DCMD_ID_SHIFT);
169 flags = (flags & ~BCDC_DCMD_IF_MASK) |
170 (ifidx << BCDC_DCMD_IF_SHIFT);
171 msg->flags = cpu_to_le32(flags);
172
173 if (buf)
174 memcpy(bcdc->buf, buf, len);
175
176 ret = brcmf_proto_bcdc_msg(drvr);
177 if (ret < 0) { 171 if (ret < 0) {
178 brcmf_err("brcmf_proto_bcdc_msg failed w/status %d\n", 172 brcmf_err("brcmf_proto_bcdc_msg failed w/status %d\n",
179 ret); 173 ret);
@@ -227,19 +221,7 @@ brcmf_proto_bcdc_set_dcmd(struct brcmf_pub *drvr, int ifidx, uint cmd,
227 221
228 brcmf_dbg(BCDC, "Enter, cmd %d len %d\n", cmd, len); 222 brcmf_dbg(BCDC, "Enter, cmd %d len %d\n", cmd, len);
229 223
230 memset(msg, 0, sizeof(struct brcmf_proto_bcdc_dcmd)); 224 ret = brcmf_proto_bcdc_msg(drvr, ifidx, cmd, buf, len, true);
231
232 msg->cmd = cpu_to_le32(cmd);
233 msg->len = cpu_to_le32(len);
234 flags = (++bcdc->reqid << BCDC_DCMD_ID_SHIFT) | BCDC_DCMD_SET;
235 flags = (flags & ~BCDC_DCMD_IF_MASK) |
236 (ifidx << BCDC_DCMD_IF_SHIFT);
237 msg->flags = cpu_to_le32(flags);
238
239 if (buf)
240 memcpy(bcdc->buf, buf, len);
241
242 ret = brcmf_proto_bcdc_msg(drvr);
243 if (ret < 0) 225 if (ret < 0)
244 goto done; 226 goto done;
245 227
@@ -347,6 +329,15 @@ brcmf_proto_bcdc_hdrpull(struct brcmf_pub *drvr, bool do_fws, u8 *ifidx,
347 return 0; 329 return 0;
348} 330}
349 331
332static int
333brcmf_proto_bcdc_txdata(struct brcmf_pub *drvr, int ifidx, u8 offset,
334 struct sk_buff *pktbuf)
335{
336 brcmf_proto_bcdc_hdrpush(drvr, ifidx, offset, pktbuf);
337 return brcmf_bus_txdata(drvr->bus_if, pktbuf);
338}
339
340
350int brcmf_proto_bcdc_attach(struct brcmf_pub *drvr) 341int brcmf_proto_bcdc_attach(struct brcmf_pub *drvr)
351{ 342{
352 struct brcmf_bcdc *bcdc; 343 struct brcmf_bcdc *bcdc;
@@ -361,15 +352,15 @@ int brcmf_proto_bcdc_attach(struct brcmf_pub *drvr)
361 goto fail; 352 goto fail;
362 } 353 }
363 354
364 drvr->proto->hdrpush = brcmf_proto_bcdc_hdrpush;
365 drvr->proto->hdrpull = brcmf_proto_bcdc_hdrpull; 355 drvr->proto->hdrpull = brcmf_proto_bcdc_hdrpull;
366 drvr->proto->query_dcmd = brcmf_proto_bcdc_query_dcmd; 356 drvr->proto->query_dcmd = brcmf_proto_bcdc_query_dcmd;
367 drvr->proto->set_dcmd = brcmf_proto_bcdc_set_dcmd; 357 drvr->proto->set_dcmd = brcmf_proto_bcdc_set_dcmd;
358 drvr->proto->txdata = brcmf_proto_bcdc_txdata;
368 drvr->proto->pd = bcdc; 359 drvr->proto->pd = bcdc;
369 360
370 drvr->hdrlen += BCDC_HEADER_LEN + BRCMF_PROT_FW_SIGNAL_MAX_TXBYTES; 361 drvr->hdrlen += BCDC_HEADER_LEN + BRCMF_PROT_FW_SIGNAL_MAX_TXBYTES;
371 drvr->bus_if->maxctl = BRCMF_DCMD_MAXLEN + 362 drvr->bus_if->maxctl = BRCMF_DCMD_MAXLEN +
372 sizeof(struct brcmf_proto_bcdc_dcmd) + ROUND_UP_MARGIN; 363 sizeof(struct brcmf_proto_bcdc_dcmd);
373 return 0; 364 return 0;
374 365
375fail: 366fail:
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c b/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c
index 91651ec7f13f..2b5cde67e728 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c
@@ -23,9 +23,17 @@
23#include <linux/completion.h> 23#include <linux/completion.h>
24#include <linux/scatterlist.h> 24#include <linux/scatterlist.h>
25#include <linux/mmc/sdio.h> 25#include <linux/mmc/sdio.h>
26#include <linux/mmc/core.h>
26#include <linux/mmc/sdio_func.h> 27#include <linux/mmc/sdio_func.h>
28#include <linux/mmc/sdio_ids.h>
27#include <linux/mmc/card.h> 29#include <linux/mmc/card.h>
30#include <linux/mmc/host.h>
31#include <linux/platform_device.h>
28#include <linux/platform_data/brcmfmac-sdio.h> 32#include <linux/platform_data/brcmfmac-sdio.h>
33#include <linux/suspend.h>
34#include <linux/errno.h>
35#include <linux/module.h>
36#include <net/cfg80211.h>
29 37
30#include <defs.h> 38#include <defs.h>
31#include <brcm_hw_ids.h> 39#include <brcm_hw_ids.h>
@@ -35,11 +43,21 @@
35#include "dhd_bus.h" 43#include "dhd_bus.h"
36#include "dhd_dbg.h" 44#include "dhd_dbg.h"
37#include "sdio_host.h" 45#include "sdio_host.h"
46#include "sdio_chip.h"
38 47
39#define SDIOH_API_ACCESS_RETRY_LIMIT 2 48#define SDIOH_API_ACCESS_RETRY_LIMIT 2
40 49
50#define SDIO_VENDOR_ID_BROADCOM 0x02d0
41 51
42static irqreturn_t brcmf_sdio_oob_irqhandler(int irq, void *dev_id) 52#define DMA_ALIGN_MASK 0x03
53
54#define SDIO_FUNC1_BLOCKSIZE 64
55#define SDIO_FUNC2_BLOCKSIZE 512
56/* Maximum milliseconds to wait for F2 to come up */
57#define SDIO_WAIT_F2RDY 3000
58
59
60static irqreturn_t brcmf_sdiod_oob_irqhandler(int irq, void *dev_id)
43{ 61{
44 struct brcmf_bus *bus_if = dev_get_drvdata(dev_id); 62 struct brcmf_bus *bus_if = dev_get_drvdata(dev_id);
45 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio; 63 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
@@ -54,27 +72,46 @@ static irqreturn_t brcmf_sdio_oob_irqhandler(int irq, void *dev_id)
54 sdiodev->irq_en = false; 72 sdiodev->irq_en = false;
55 } 73 }
56 74
57 brcmf_sdbrcm_isr(sdiodev->bus); 75 brcmf_sdio_isr(sdiodev->bus);
58 76
59 return IRQ_HANDLED; 77 return IRQ_HANDLED;
60} 78}
61 79
62static void brcmf_sdio_ib_irqhandler(struct sdio_func *func) 80static void brcmf_sdiod_ib_irqhandler(struct sdio_func *func)
63{ 81{
64 struct brcmf_bus *bus_if = dev_get_drvdata(&func->dev); 82 struct brcmf_bus *bus_if = dev_get_drvdata(&func->dev);
65 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio; 83 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
66 84
67 brcmf_dbg(INTR, "IB intr triggered\n"); 85 brcmf_dbg(INTR, "IB intr triggered\n");
68 86
69 brcmf_sdbrcm_isr(sdiodev->bus); 87 brcmf_sdio_isr(sdiodev->bus);
70} 88}
71 89
72/* dummy handler for SDIO function 2 interrupt */ 90/* dummy handler for SDIO function 2 interrupt */
73static void brcmf_sdio_dummy_irqhandler(struct sdio_func *func) 91static void brcmf_sdiod_dummy_irqhandler(struct sdio_func *func)
92{
93}
94
95static bool brcmf_sdiod_pm_resume_error(struct brcmf_sdio_dev *sdiodev)
74{ 96{
97 bool is_err = false;
98#ifdef CONFIG_PM_SLEEP
99 is_err = atomic_read(&sdiodev->suspend);
100#endif
101 return is_err;
75} 102}
76 103
77int brcmf_sdio_intr_register(struct brcmf_sdio_dev *sdiodev) 104static void brcmf_sdiod_pm_resume_wait(struct brcmf_sdio_dev *sdiodev,
105 wait_queue_head_t *wq)
106{
107#ifdef CONFIG_PM_SLEEP
108 int retry = 0;
109 while (atomic_read(&sdiodev->suspend) && retry++ != 30)
110 wait_event_timeout(*wq, false, HZ/100);
111#endif
112}
113
114int brcmf_sdiod_intr_register(struct brcmf_sdio_dev *sdiodev)
78{ 115{
79 int ret = 0; 116 int ret = 0;
80 u8 data; 117 u8 data;
@@ -84,7 +121,7 @@ int brcmf_sdio_intr_register(struct brcmf_sdio_dev *sdiodev)
84 brcmf_dbg(SDIO, "Enter, register OOB IRQ %d\n", 121 brcmf_dbg(SDIO, "Enter, register OOB IRQ %d\n",
85 sdiodev->pdata->oob_irq_nr); 122 sdiodev->pdata->oob_irq_nr);
86 ret = request_irq(sdiodev->pdata->oob_irq_nr, 123 ret = request_irq(sdiodev->pdata->oob_irq_nr,
87 brcmf_sdio_oob_irqhandler, 124 brcmf_sdiod_oob_irqhandler,
88 sdiodev->pdata->oob_irq_flags, 125 sdiodev->pdata->oob_irq_flags,
89 "brcmf_oob_intr", 126 "brcmf_oob_intr",
90 &sdiodev->func[1]->dev); 127 &sdiodev->func[1]->dev);
@@ -108,36 +145,36 @@ int brcmf_sdio_intr_register(struct brcmf_sdio_dev *sdiodev)
108 sdio_claim_host(sdiodev->func[1]); 145 sdio_claim_host(sdiodev->func[1]);
109 146
110 /* must configure SDIO_CCCR_IENx to enable irq */ 147 /* must configure SDIO_CCCR_IENx to enable irq */
111 data = brcmf_sdio_regrb(sdiodev, SDIO_CCCR_IENx, &ret); 148 data = brcmf_sdiod_regrb(sdiodev, SDIO_CCCR_IENx, &ret);
112 data |= 1 << SDIO_FUNC_1 | 1 << SDIO_FUNC_2 | 1; 149 data |= 1 << SDIO_FUNC_1 | 1 << SDIO_FUNC_2 | 1;
113 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_IENx, data, &ret); 150 brcmf_sdiod_regwb(sdiodev, SDIO_CCCR_IENx, data, &ret);
114 151
115 /* redirect, configure and enable io for interrupt signal */ 152 /* redirect, configure and enable io for interrupt signal */
116 data = SDIO_SEPINT_MASK | SDIO_SEPINT_OE; 153 data = SDIO_SEPINT_MASK | SDIO_SEPINT_OE;
117 if (sdiodev->pdata->oob_irq_flags & IRQF_TRIGGER_HIGH) 154 if (sdiodev->pdata->oob_irq_flags & IRQF_TRIGGER_HIGH)
118 data |= SDIO_SEPINT_ACT_HI; 155 data |= SDIO_SEPINT_ACT_HI;
119 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, data, &ret); 156 brcmf_sdiod_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, data, &ret);
120 157
121 sdio_release_host(sdiodev->func[1]); 158 sdio_release_host(sdiodev->func[1]);
122 } else { 159 } else {
123 brcmf_dbg(SDIO, "Entering\n"); 160 brcmf_dbg(SDIO, "Entering\n");
124 sdio_claim_host(sdiodev->func[1]); 161 sdio_claim_host(sdiodev->func[1]);
125 sdio_claim_irq(sdiodev->func[1], brcmf_sdio_ib_irqhandler); 162 sdio_claim_irq(sdiodev->func[1], brcmf_sdiod_ib_irqhandler);
126 sdio_claim_irq(sdiodev->func[2], brcmf_sdio_dummy_irqhandler); 163 sdio_claim_irq(sdiodev->func[2], brcmf_sdiod_dummy_irqhandler);
127 sdio_release_host(sdiodev->func[1]); 164 sdio_release_host(sdiodev->func[1]);
128 } 165 }
129 166
130 return 0; 167 return 0;
131} 168}
132 169
133int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev *sdiodev) 170int brcmf_sdiod_intr_unregister(struct brcmf_sdio_dev *sdiodev)
134{ 171{
135 brcmf_dbg(SDIO, "Entering\n"); 172 brcmf_dbg(SDIO, "Entering\n");
136 173
137 if ((sdiodev->pdata) && (sdiodev->pdata->oob_irq_supported)) { 174 if ((sdiodev->pdata) && (sdiodev->pdata->oob_irq_supported)) {
138 sdio_claim_host(sdiodev->func[1]); 175 sdio_claim_host(sdiodev->func[1]);
139 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, 0, NULL); 176 brcmf_sdiod_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, 0, NULL);
140 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_IENx, 0, NULL); 177 brcmf_sdiod_regwb(sdiodev, SDIO_CCCR_IENx, 0, NULL);
141 sdio_release_host(sdiodev->func[1]); 178 sdio_release_host(sdiodev->func[1]);
142 179
143 if (sdiodev->oob_irq_requested) { 180 if (sdiodev->oob_irq_requested) {
@@ -160,8 +197,117 @@ int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev *sdiodev)
160 return 0; 197 return 0;
161} 198}
162 199
200static inline int brcmf_sdiod_f0_writeb(struct sdio_func *func,
201 uint regaddr, u8 byte)
202{
203 int err_ret;
204
205 /*
206 * Can only directly write to some F0 registers.
207 * Handle CCCR_IENx and CCCR_ABORT command
208 * as a special case.
209 */
210 if ((regaddr == SDIO_CCCR_ABORT) ||
211 (regaddr == SDIO_CCCR_IENx))
212 sdio_writeb(func, byte, regaddr, &err_ret);
213 else
214 sdio_f0_writeb(func, byte, regaddr, &err_ret);
215
216 return err_ret;
217}
218
219static int brcmf_sdiod_request_byte(struct brcmf_sdio_dev *sdiodev, uint rw,
220 uint func, uint regaddr, u8 *byte)
221{
222 int err_ret;
223
224 brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x\n", rw, func, regaddr);
225
226 brcmf_sdiod_pm_resume_wait(sdiodev, &sdiodev->request_byte_wait);
227 if (brcmf_sdiod_pm_resume_error(sdiodev))
228 return -EIO;
229
230 if (rw && func == 0) {
231 /* handle F0 separately */
232 err_ret = brcmf_sdiod_f0_writeb(sdiodev->func[func],
233 regaddr, *byte);
234 } else {
235 if (rw) /* CMD52 Write */
236 sdio_writeb(sdiodev->func[func], *byte, regaddr,
237 &err_ret);
238 else if (func == 0) {
239 *byte = sdio_f0_readb(sdiodev->func[func], regaddr,
240 &err_ret);
241 } else {
242 *byte = sdio_readb(sdiodev->func[func], regaddr,
243 &err_ret);
244 }
245 }
246
247 if (err_ret) {
248 /*
249 * SleepCSR register access can fail when
250 * waking up the device so reduce this noise
251 * in the logs.
252 */
253 if (regaddr != SBSDIO_FUNC1_SLEEPCSR)
254 brcmf_err("Failed to %s byte F%d:@0x%05x=%02x, Err: %d\n",
255 rw ? "write" : "read", func, regaddr, *byte,
256 err_ret);
257 else
258 brcmf_dbg(SDIO, "Failed to %s byte F%d:@0x%05x=%02x, Err: %d\n",
259 rw ? "write" : "read", func, regaddr, *byte,
260 err_ret);
261 }
262 return err_ret;
263}
264
265static int brcmf_sdiod_request_word(struct brcmf_sdio_dev *sdiodev, uint rw,
266 uint func, uint addr, u32 *word,
267 uint nbytes)
268{
269 int err_ret = -EIO;
270
271 if (func == 0) {
272 brcmf_err("Only CMD52 allowed to F0\n");
273 return -EINVAL;
274 }
275
276 brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",
277 rw, func, addr, nbytes);
278
279 brcmf_sdiod_pm_resume_wait(sdiodev, &sdiodev->request_word_wait);
280 if (brcmf_sdiod_pm_resume_error(sdiodev))
281 return -EIO;
282
283 if (rw) { /* CMD52 Write */
284 if (nbytes == 4)
285 sdio_writel(sdiodev->func[func], *word, addr,
286 &err_ret);
287 else if (nbytes == 2)
288 sdio_writew(sdiodev->func[func], (*word & 0xFFFF),
289 addr, &err_ret);
290 else
291 brcmf_err("Invalid nbytes: %d\n", nbytes);
292 } else { /* CMD52 Read */
293 if (nbytes == 4)
294 *word = sdio_readl(sdiodev->func[func], addr, &err_ret);
295 else if (nbytes == 2)
296 *word = sdio_readw(sdiodev->func[func], addr,
297 &err_ret) & 0xFFFF;
298 else
299 brcmf_err("Invalid nbytes: %d\n", nbytes);
300 }
301
302 if (err_ret)
303 brcmf_err("Failed to %s word, Err: 0x%08x\n",
304 rw ? "write" : "read", err_ret);
305
306 return err_ret;
307}
308
163static int 309static int
164brcmf_sdcard_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address) 310brcmf_sdiod_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
165{ 311{
166 int err = 0, i; 312 int err = 0, i;
167 u8 addr[3]; 313 u8 addr[3];
@@ -176,7 +322,7 @@ brcmf_sdcard_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
176 do { 322 do {
177 if (retry) 323 if (retry)
178 usleep_range(1000, 2000); 324 usleep_range(1000, 2000);
179 err = brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, 325 err = brcmf_sdiod_request_byte(sdiodev, SDIOH_WRITE,
180 SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW + i, 326 SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW + i,
181 &addr[i]); 327 &addr[i]);
182 } while (err != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT); 328 } while (err != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
@@ -192,13 +338,13 @@ brcmf_sdcard_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
192} 338}
193 339
194static int 340static int
195brcmf_sdio_addrprep(struct brcmf_sdio_dev *sdiodev, uint width, u32 *addr) 341brcmf_sdiod_addrprep(struct brcmf_sdio_dev *sdiodev, uint width, u32 *addr)
196{ 342{
197 uint bar0 = *addr & ~SBSDIO_SB_OFT_ADDR_MASK; 343 uint bar0 = *addr & ~SBSDIO_SB_OFT_ADDR_MASK;
198 int err = 0; 344 int err = 0;
199 345
200 if (bar0 != sdiodev->sbwad) { 346 if (bar0 != sdiodev->sbwad) {
201 err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0); 347 err = brcmf_sdiod_set_sbaddr_window(sdiodev, bar0);
202 if (err) 348 if (err)
203 return err; 349 return err;
204 350
@@ -213,9 +359,8 @@ brcmf_sdio_addrprep(struct brcmf_sdio_dev *sdiodev, uint width, u32 *addr)
213 return 0; 359 return 0;
214} 360}
215 361
216int 362static int brcmf_sdiod_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
217brcmf_sdio_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr, 363 void *data, bool write)
218 void *data, bool write)
219{ 364{
220 u8 func_num, reg_size; 365 u8 func_num, reg_size;
221 s32 retry = 0; 366 s32 retry = 0;
@@ -237,7 +382,7 @@ brcmf_sdio_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
237 func_num = SDIO_FUNC_1; 382 func_num = SDIO_FUNC_1;
238 reg_size = 4; 383 reg_size = 4;
239 384
240 ret = brcmf_sdio_addrprep(sdiodev, reg_size, &addr); 385 ret = brcmf_sdiod_addrprep(sdiodev, reg_size, &addr);
241 if (ret) 386 if (ret)
242 goto done; 387 goto done;
243 } 388 }
@@ -248,10 +393,10 @@ brcmf_sdio_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
248 if (retry) /* wait for 1 ms till bus get settled down */ 393 if (retry) /* wait for 1 ms till bus get settled down */
249 usleep_range(1000, 2000); 394 usleep_range(1000, 2000);
250 if (reg_size == 1) 395 if (reg_size == 1)
251 ret = brcmf_sdioh_request_byte(sdiodev, write, 396 ret = brcmf_sdiod_request_byte(sdiodev, write,
252 func_num, addr, data); 397 func_num, addr, data);
253 else 398 else
254 ret = brcmf_sdioh_request_word(sdiodev, write, 399 ret = brcmf_sdiod_request_word(sdiodev, write,
255 func_num, addr, data, 4); 400 func_num, addr, data, 4);
256 } while (ret != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT); 401 } while (ret != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
257 402
@@ -262,13 +407,13 @@ done:
262 return ret; 407 return ret;
263} 408}
264 409
265u8 brcmf_sdio_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret) 410u8 brcmf_sdiod_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
266{ 411{
267 u8 data; 412 u8 data;
268 int retval; 413 int retval;
269 414
270 brcmf_dbg(SDIO, "addr:0x%08x\n", addr); 415 brcmf_dbg(SDIO, "addr:0x%08x\n", addr);
271 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, false); 416 retval = brcmf_sdiod_regrw_helper(sdiodev, addr, &data, false);
272 brcmf_dbg(SDIO, "data:0x%02x\n", data); 417 brcmf_dbg(SDIO, "data:0x%02x\n", data);
273 418
274 if (ret) 419 if (ret)
@@ -277,13 +422,13 @@ u8 brcmf_sdio_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
277 return data; 422 return data;
278} 423}
279 424
280u32 brcmf_sdio_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret) 425u32 brcmf_sdiod_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
281{ 426{
282 u32 data; 427 u32 data;
283 int retval; 428 int retval;
284 429
285 brcmf_dbg(SDIO, "addr:0x%08x\n", addr); 430 brcmf_dbg(SDIO, "addr:0x%08x\n", addr);
286 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, false); 431 retval = brcmf_sdiod_regrw_helper(sdiodev, addr, &data, false);
287 brcmf_dbg(SDIO, "data:0x%08x\n", data); 432 brcmf_dbg(SDIO, "data:0x%08x\n", data);
288 433
289 if (ret) 434 if (ret)
@@ -292,37 +437,37 @@ u32 brcmf_sdio_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
292 return data; 437 return data;
293} 438}
294 439
295void brcmf_sdio_regwb(struct brcmf_sdio_dev *sdiodev, u32 addr, 440void brcmf_sdiod_regwb(struct brcmf_sdio_dev *sdiodev, u32 addr,
296 u8 data, int *ret) 441 u8 data, int *ret)
297{ 442{
298 int retval; 443 int retval;
299 444
300 brcmf_dbg(SDIO, "addr:0x%08x, data:0x%02x\n", addr, data); 445 brcmf_dbg(SDIO, "addr:0x%08x, data:0x%02x\n", addr, data);
301 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, true); 446 retval = brcmf_sdiod_regrw_helper(sdiodev, addr, &data, true);
302 447
303 if (ret) 448 if (ret)
304 *ret = retval; 449 *ret = retval;
305} 450}
306 451
307void brcmf_sdio_regwl(struct brcmf_sdio_dev *sdiodev, u32 addr, 452void brcmf_sdiod_regwl(struct brcmf_sdio_dev *sdiodev, u32 addr,
308 u32 data, int *ret) 453 u32 data, int *ret)
309{ 454{
310 int retval; 455 int retval;
311 456
312 brcmf_dbg(SDIO, "addr:0x%08x, data:0x%08x\n", addr, data); 457 brcmf_dbg(SDIO, "addr:0x%08x, data:0x%08x\n", addr, data);
313 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, true); 458 retval = brcmf_sdiod_regrw_helper(sdiodev, addr, &data, true);
314 459
315 if (ret) 460 if (ret)
316 *ret = retval; 461 *ret = retval;
317} 462}
318 463
319static int brcmf_sdio_buffrw(struct brcmf_sdio_dev *sdiodev, uint fn, 464static int brcmf_sdiod_buffrw(struct brcmf_sdio_dev *sdiodev, uint fn,
320 bool write, u32 addr, struct sk_buff *pkt) 465 bool write, u32 addr, struct sk_buff *pkt)
321{ 466{
322 unsigned int req_sz; 467 unsigned int req_sz;
323 468
324 brcmf_pm_resume_wait(sdiodev, &sdiodev->request_buffer_wait); 469 brcmf_sdiod_pm_resume_wait(sdiodev, &sdiodev->request_buffer_wait);
325 if (brcmf_pm_resume_error(sdiodev)) 470 if (brcmf_sdiod_pm_resume_error(sdiodev))
326 return -EIO; 471 return -EIO;
327 472
328 /* Single skb use the standard mmc interface */ 473 /* Single skb use the standard mmc interface */
@@ -345,7 +490,7 @@ static int brcmf_sdio_buffrw(struct brcmf_sdio_dev *sdiodev, uint fn,
345} 490}
346 491
347/** 492/**
348 * brcmf_sdio_sglist_rw - SDIO interface function for block data access 493 * brcmf_sdiod_sglist_rw - SDIO interface function for block data access
349 * @sdiodev: brcmfmac sdio device 494 * @sdiodev: brcmfmac sdio device
350 * @fn: SDIO function number 495 * @fn: SDIO function number
351 * @write: direction flag 496 * @write: direction flag
@@ -356,9 +501,9 @@ static int brcmf_sdio_buffrw(struct brcmf_sdio_dev *sdiodev, uint fn,
356 * stack for block data access. It assumes that the skb passed down by the 501 * stack for block data access. It assumes that the skb passed down by the
357 * caller has already been padded and aligned. 502 * caller has already been padded and aligned.
358 */ 503 */
359static int brcmf_sdio_sglist_rw(struct brcmf_sdio_dev *sdiodev, uint fn, 504static int brcmf_sdiod_sglist_rw(struct brcmf_sdio_dev *sdiodev, uint fn,
360 bool write, u32 addr, 505 bool write, u32 addr,
361 struct sk_buff_head *pktlist) 506 struct sk_buff_head *pktlist)
362{ 507{
363 unsigned int req_sz, func_blk_sz, sg_cnt, sg_data_sz, pkt_offset; 508 unsigned int req_sz, func_blk_sz, sg_cnt, sg_data_sz, pkt_offset;
364 unsigned int max_req_sz, orig_offset, dst_offset; 509 unsigned int max_req_sz, orig_offset, dst_offset;
@@ -376,8 +521,8 @@ static int brcmf_sdio_sglist_rw(struct brcmf_sdio_dev *sdiodev, uint fn,
376 if (!pktlist->qlen) 521 if (!pktlist->qlen)
377 return -EINVAL; 522 return -EINVAL;
378 523
379 brcmf_pm_resume_wait(sdiodev, &sdiodev->request_buffer_wait); 524 brcmf_sdiod_pm_resume_wait(sdiodev, &sdiodev->request_buffer_wait);
380 if (brcmf_pm_resume_error(sdiodev)) 525 if (brcmf_sdiod_pm_resume_error(sdiodev))
381 return -EIO; 526 return -EIO;
382 527
383 target_list = pktlist; 528 target_list = pktlist;
@@ -524,9 +669,7 @@ exit:
524 return ret; 669 return ret;
525} 670}
526 671
527int 672int brcmf_sdiod_recv_buf(struct brcmf_sdio_dev *sdiodev, u8 *buf, uint nbytes)
528brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
529 uint flags, u8 *buf, uint nbytes)
530{ 673{
531 struct sk_buff *mypkt; 674 struct sk_buff *mypkt;
532 int err; 675 int err;
@@ -538,7 +681,7 @@ brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
538 return -EIO; 681 return -EIO;
539 } 682 }
540 683
541 err = brcmf_sdcard_recv_pkt(sdiodev, addr, fn, flags, mypkt); 684 err = brcmf_sdiod_recv_pkt(sdiodev, mypkt);
542 if (!err) 685 if (!err)
543 memcpy(buf, mypkt->data, nbytes); 686 memcpy(buf, mypkt->data, nbytes);
544 687
@@ -546,50 +689,47 @@ brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
546 return err; 689 return err;
547} 690}
548 691
549int 692int brcmf_sdiod_recv_pkt(struct brcmf_sdio_dev *sdiodev, struct sk_buff *pkt)
550brcmf_sdcard_recv_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
551 uint flags, struct sk_buff *pkt)
552{ 693{
553 uint width; 694 u32 addr = sdiodev->sbwad;
554 int err = 0; 695 int err = 0;
555 696
556 brcmf_dbg(SDIO, "fun = %d, addr = 0x%x, size = %d\n", 697 brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n", addr, pkt->len);
557 fn, addr, pkt->len);
558 698
559 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2; 699 err = brcmf_sdiod_addrprep(sdiodev, 4, &addr);
560 err = brcmf_sdio_addrprep(sdiodev, width, &addr);
561 if (err) 700 if (err)
562 goto done; 701 goto done;
563 702
564 err = brcmf_sdio_buffrw(sdiodev, fn, false, addr, pkt); 703 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, false, addr, pkt);
565 704
566done: 705done:
567 return err; 706 return err;
568} 707}
569 708
570int brcmf_sdcard_recv_chain(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn, 709int brcmf_sdiod_recv_chain(struct brcmf_sdio_dev *sdiodev,
571 uint flags, struct sk_buff_head *pktq, uint totlen) 710 struct sk_buff_head *pktq, uint totlen)
572{ 711{
573 struct sk_buff *glom_skb; 712 struct sk_buff *glom_skb;
574 struct sk_buff *skb; 713 struct sk_buff *skb;
575 uint width; 714 u32 addr = sdiodev->sbwad;
576 int err = 0; 715 int err = 0;
577 716
578 brcmf_dbg(SDIO, "fun = %d, addr = 0x%x, size = %d\n", 717 brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n",
579 fn, addr, pktq->qlen); 718 addr, pktq->qlen);
580 719
581 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2; 720 err = brcmf_sdiod_addrprep(sdiodev, 4, &addr);
582 err = brcmf_sdio_addrprep(sdiodev, width, &addr);
583 if (err) 721 if (err)
584 goto done; 722 goto done;
585 723
586 if (pktq->qlen == 1) 724 if (pktq->qlen == 1)
587 err = brcmf_sdio_buffrw(sdiodev, fn, false, addr, pktq->next); 725 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, false, addr,
726 pktq->next);
588 else if (!sdiodev->sg_support) { 727 else if (!sdiodev->sg_support) {
589 glom_skb = brcmu_pkt_buf_get_skb(totlen); 728 glom_skb = brcmu_pkt_buf_get_skb(totlen);
590 if (!glom_skb) 729 if (!glom_skb)
591 return -ENOMEM; 730 return -ENOMEM;
592 err = brcmf_sdio_buffrw(sdiodev, fn, false, addr, glom_skb); 731 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, false, addr,
732 glom_skb);
593 if (err) 733 if (err)
594 goto done; 734 goto done;
595 735
@@ -598,18 +738,17 @@ int brcmf_sdcard_recv_chain(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
598 skb_pull(glom_skb, skb->len); 738 skb_pull(glom_skb, skb->len);
599 } 739 }
600 } else 740 } else
601 err = brcmf_sdio_sglist_rw(sdiodev, fn, false, addr, pktq); 741 err = brcmf_sdiod_sglist_rw(sdiodev, SDIO_FUNC_2, false, addr,
742 pktq);
602 743
603done: 744done:
604 return err; 745 return err;
605} 746}
606 747
607int 748int brcmf_sdiod_send_buf(struct brcmf_sdio_dev *sdiodev, u8 *buf, uint nbytes)
608brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
609 uint flags, u8 *buf, uint nbytes)
610{ 749{
611 struct sk_buff *mypkt; 750 struct sk_buff *mypkt;
612 uint width; 751 u32 addr = sdiodev->sbwad;
613 int err; 752 int err;
614 753
615 mypkt = brcmu_pkt_buf_get_skb(nbytes); 754 mypkt = brcmu_pkt_buf_get_skb(nbytes);
@@ -621,48 +760,47 @@ brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
621 760
622 memcpy(mypkt->data, buf, nbytes); 761 memcpy(mypkt->data, buf, nbytes);
623 762
624 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2; 763 err = brcmf_sdiod_addrprep(sdiodev, 4, &addr);
625 err = brcmf_sdio_addrprep(sdiodev, width, &addr);
626 764
627 if (!err) 765 if (!err)
628 err = brcmf_sdio_buffrw(sdiodev, fn, true, addr, mypkt); 766 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, true, addr,
767 mypkt);
629 768
630 brcmu_pkt_buf_free_skb(mypkt); 769 brcmu_pkt_buf_free_skb(mypkt);
631 return err; 770 return err;
632 771
633} 772}
634 773
635int 774int brcmf_sdiod_send_pkt(struct brcmf_sdio_dev *sdiodev,
636brcmf_sdcard_send_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn, 775 struct sk_buff_head *pktq)
637 uint flags, struct sk_buff_head *pktq)
638{ 776{
639 struct sk_buff *skb; 777 struct sk_buff *skb;
640 uint width; 778 u32 addr = sdiodev->sbwad;
641 int err; 779 int err;
642 780
643 brcmf_dbg(SDIO, "fun = %d, addr = 0x%x, size = %d\n", 781 brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n", addr, pktq->qlen);
644 fn, addr, pktq->qlen);
645 782
646 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2; 783 err = brcmf_sdiod_addrprep(sdiodev, 4, &addr);
647 err = brcmf_sdio_addrprep(sdiodev, width, &addr);
648 if (err) 784 if (err)
649 return err; 785 return err;
650 786
651 if (pktq->qlen == 1 || !sdiodev->sg_support) 787 if (pktq->qlen == 1 || !sdiodev->sg_support)
652 skb_queue_walk(pktq, skb) { 788 skb_queue_walk(pktq, skb) {
653 err = brcmf_sdio_buffrw(sdiodev, fn, true, addr, skb); 789 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, true,
790 addr, skb);
654 if (err) 791 if (err)
655 break; 792 break;
656 } 793 }
657 else 794 else
658 err = brcmf_sdio_sglist_rw(sdiodev, fn, true, addr, pktq); 795 err = brcmf_sdiod_sglist_rw(sdiodev, SDIO_FUNC_2, true, addr,
796 pktq);
659 797
660 return err; 798 return err;
661} 799}
662 800
663int 801int
664brcmf_sdio_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address, 802brcmf_sdiod_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
665 u8 *data, uint size) 803 u8 *data, uint size)
666{ 804{
667 int bcmerror = 0; 805 int bcmerror = 0;
668 struct sk_buff *pkt; 806 struct sk_buff *pkt;
@@ -689,7 +827,7 @@ brcmf_sdio_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
689 /* Do the transfer(s) */ 827 /* Do the transfer(s) */
690 while (size) { 828 while (size) {
691 /* Set the backplane window to include the start address */ 829 /* Set the backplane window to include the start address */
692 bcmerror = brcmf_sdcard_set_sbaddr_window(sdiodev, address); 830 bcmerror = brcmf_sdiod_set_sbaddr_window(sdiodev, address);
693 if (bcmerror) 831 if (bcmerror)
694 break; 832 break;
695 833
@@ -703,8 +841,8 @@ brcmf_sdio_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
703 skb_put(pkt, dsize); 841 skb_put(pkt, dsize);
704 if (write) 842 if (write)
705 memcpy(pkt->data, data, dsize); 843 memcpy(pkt->data, data, dsize);
706 bcmerror = brcmf_sdio_buffrw(sdiodev, SDIO_FUNC_1, write, 844 bcmerror = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_1, write,
707 sdaddr, pkt); 845 sdaddr, pkt);
708 if (bcmerror) { 846 if (bcmerror) {
709 brcmf_err("membytes transfer failed\n"); 847 brcmf_err("membytes transfer failed\n");
710 break; 848 break;
@@ -726,7 +864,7 @@ brcmf_sdio_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
726 dev_kfree_skb(pkt); 864 dev_kfree_skb(pkt);
727 865
728 /* Return the window to backplane enumeration space for core access */ 866 /* Return the window to backplane enumeration space for core access */
729 if (brcmf_sdcard_set_sbaddr_window(sdiodev, sdiodev->sbwad)) 867 if (brcmf_sdiod_set_sbaddr_window(sdiodev, sdiodev->sbwad))
730 brcmf_err("FAILED to set window back to 0x%x\n", 868 brcmf_err("FAILED to set window back to 0x%x\n",
731 sdiodev->sbwad); 869 sdiodev->sbwad);
732 870
@@ -735,65 +873,337 @@ brcmf_sdio_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
735 return bcmerror; 873 return bcmerror;
736} 874}
737 875
738int brcmf_sdcard_abort(struct brcmf_sdio_dev *sdiodev, uint fn) 876int brcmf_sdiod_abort(struct brcmf_sdio_dev *sdiodev, uint fn)
739{ 877{
740 char t_func = (char)fn; 878 char t_func = (char)fn;
741 brcmf_dbg(SDIO, "Enter\n"); 879 brcmf_dbg(SDIO, "Enter\n");
742 880
743 /* issue abort cmd52 command through F0 */ 881 /* issue abort cmd52 command through F0 */
744 brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, SDIO_FUNC_0, 882 brcmf_sdiod_request_byte(sdiodev, SDIOH_WRITE, SDIO_FUNC_0,
745 SDIO_CCCR_ABORT, &t_func); 883 SDIO_CCCR_ABORT, &t_func);
746 884
747 brcmf_dbg(SDIO, "Exit\n"); 885 brcmf_dbg(SDIO, "Exit\n");
748 return 0; 886 return 0;
749} 887}
750 888
751int brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev) 889static int brcmf_sdiod_remove(struct brcmf_sdio_dev *sdiodev)
890{
891 sdiodev->bus_if->state = BRCMF_BUS_DOWN;
892
893 if (sdiodev->bus) {
894 brcmf_sdio_remove(sdiodev->bus);
895 sdiodev->bus = NULL;
896 }
897
898 /* Disable Function 2 */
899 sdio_claim_host(sdiodev->func[2]);
900 sdio_disable_func(sdiodev->func[2]);
901 sdio_release_host(sdiodev->func[2]);
902
903 /* Disable Function 1 */
904 sdio_claim_host(sdiodev->func[1]);
905 sdio_disable_func(sdiodev->func[1]);
906 sdio_release_host(sdiodev->func[1]);
907
908 sdiodev->sbwad = 0;
909
910 return 0;
911}
912
913static int brcmf_sdiod_probe(struct brcmf_sdio_dev *sdiodev)
752{ 914{
753 u32 regs = 0; 915 struct sdio_func *func;
916 struct mmc_host *host;
917 uint max_blocks;
754 int ret = 0; 918 int ret = 0;
755 919
756 ret = brcmf_sdioh_attach(sdiodev); 920 sdiodev->num_funcs = 2;
757 if (ret) 921
922 sdio_claim_host(sdiodev->func[1]);
923
924 ret = sdio_set_block_size(sdiodev->func[1], SDIO_FUNC1_BLOCKSIZE);
925 if (ret) {
926 brcmf_err("Failed to set F1 blocksize\n");
927 sdio_release_host(sdiodev->func[1]);
928 goto out;
929 }
930 ret = sdio_set_block_size(sdiodev->func[2], SDIO_FUNC2_BLOCKSIZE);
931 if (ret) {
932 brcmf_err("Failed to set F2 blocksize\n");
933 sdio_release_host(sdiodev->func[1]);
934 goto out;
935 }
936
937 /* increase F2 timeout */
938 sdiodev->func[2]->enable_timeout = SDIO_WAIT_F2RDY;
939
940 /* Enable Function 1 */
941 ret = sdio_enable_func(sdiodev->func[1]);
942 sdio_release_host(sdiodev->func[1]);
943 if (ret) {
944 brcmf_err("Failed to enable F1: err=%d\n", ret);
758 goto out; 945 goto out;
946 }
759 947
760 regs = SI_ENUM_BASE; 948 /*
949 * determine host related variables after brcmf_sdiod_probe()
950 * as func->cur_blksize is properly set and F2 init has been
951 * completed successfully.
952 */
953 func = sdiodev->func[2];
954 host = func->card->host;
955 sdiodev->sg_support = host->max_segs > 1;
956 max_blocks = min_t(uint, host->max_blk_count, 511u);
957 sdiodev->max_request_size = min_t(uint, host->max_req_size,
958 max_blocks * func->cur_blksize);
959 sdiodev->max_segment_count = min_t(uint, host->max_segs,
960 SG_MAX_SINGLE_ALLOC);
961 sdiodev->max_segment_size = host->max_seg_size;
761 962
762 /* try to attach to the target device */ 963 /* try to attach to the target device */
763 sdiodev->bus = brcmf_sdbrcm_probe(regs, sdiodev); 964 sdiodev->bus = brcmf_sdio_probe(sdiodev);
764 if (!sdiodev->bus) { 965 if (!sdiodev->bus) {
765 brcmf_err("device attach failed\n");
766 ret = -ENODEV; 966 ret = -ENODEV;
767 goto out; 967 goto out;
768 } 968 }
769 969
770out: 970out:
771 if (ret) 971 if (ret)
772 brcmf_sdio_remove(sdiodev); 972 brcmf_sdiod_remove(sdiodev);
773 973
774 return ret; 974 return ret;
775} 975}
776 976
777int brcmf_sdio_remove(struct brcmf_sdio_dev *sdiodev) 977/* devices we support, null terminated */
978static const struct sdio_device_id brcmf_sdmmc_ids[] = {
979 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_43143)},
980 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_43241)},
981 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_4329)},
982 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_4330)},
983 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_4334)},
984 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM,
985 SDIO_DEVICE_ID_BROADCOM_4335_4339)},
986 { /* end: all zeroes */ },
987};
988MODULE_DEVICE_TABLE(sdio, brcmf_sdmmc_ids);
989
990static struct brcmfmac_sdio_platform_data *brcmfmac_sdio_pdata;
991
992
993static int brcmf_ops_sdio_probe(struct sdio_func *func,
994 const struct sdio_device_id *id)
778{ 995{
779 sdiodev->bus_if->state = BRCMF_BUS_DOWN; 996 int err;
997 struct brcmf_sdio_dev *sdiodev;
998 struct brcmf_bus *bus_if;
780 999
781 if (sdiodev->bus) { 1000 brcmf_dbg(SDIO, "Enter\n");
782 brcmf_sdbrcm_disconnect(sdiodev->bus); 1001 brcmf_dbg(SDIO, "Class=%x\n", func->class);
783 sdiodev->bus = NULL; 1002 brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
1003 brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
1004 brcmf_dbg(SDIO, "Function#: %d\n", func->num);
1005
1006 /* Consume func num 1 but dont do anything with it. */
1007 if (func->num == 1)
1008 return 0;
1009
1010 /* Ignore anything but func 2 */
1011 if (func->num != 2)
1012 return -ENODEV;
1013
1014 bus_if = kzalloc(sizeof(struct brcmf_bus), GFP_KERNEL);
1015 if (!bus_if)
1016 return -ENOMEM;
1017 sdiodev = kzalloc(sizeof(struct brcmf_sdio_dev), GFP_KERNEL);
1018 if (!sdiodev) {
1019 kfree(bus_if);
1020 return -ENOMEM;
784 } 1021 }
785 1022
786 brcmf_sdioh_detach(sdiodev); 1023 /* store refs to functions used. mmc_card does
1024 * not hold the F0 function pointer.
1025 */
1026 sdiodev->func[0] = kmemdup(func, sizeof(*func), GFP_KERNEL);
1027 sdiodev->func[0]->num = 0;
1028 sdiodev->func[1] = func->card->sdio_func[0];
1029 sdiodev->func[2] = func;
1030
1031 sdiodev->bus_if = bus_if;
1032 bus_if->bus_priv.sdio = sdiodev;
1033 bus_if->proto_type = BRCMF_PROTO_BCDC;
1034 dev_set_drvdata(&func->dev, bus_if);
1035 dev_set_drvdata(&sdiodev->func[1]->dev, bus_if);
1036 sdiodev->dev = &sdiodev->func[1]->dev;
1037 sdiodev->pdata = brcmfmac_sdio_pdata;
1038
1039 atomic_set(&sdiodev->suspend, false);
1040 init_waitqueue_head(&sdiodev->request_byte_wait);
1041 init_waitqueue_head(&sdiodev->request_word_wait);
1042 init_waitqueue_head(&sdiodev->request_buffer_wait);
1043
1044 brcmf_dbg(SDIO, "F2 found, calling brcmf_sdiod_probe...\n");
1045 err = brcmf_sdiod_probe(sdiodev);
1046 if (err) {
1047 brcmf_err("F2 error, probe failed %d...\n", err);
1048 goto fail;
1049 }
787 1050
788 sdiodev->sbwad = 0; 1051 brcmf_dbg(SDIO, "F2 init completed...\n");
1052 return 0;
1053
1054fail:
1055 dev_set_drvdata(&func->dev, NULL);
1056 dev_set_drvdata(&sdiodev->func[1]->dev, NULL);
1057 kfree(sdiodev->func[0]);
1058 kfree(sdiodev);
1059 kfree(bus_if);
1060 return err;
1061}
1062
1063static void brcmf_ops_sdio_remove(struct sdio_func *func)
1064{
1065 struct brcmf_bus *bus_if;
1066 struct brcmf_sdio_dev *sdiodev;
1067
1068 brcmf_dbg(SDIO, "Enter\n");
1069 brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
1070 brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
1071 brcmf_dbg(SDIO, "Function: %d\n", func->num);
1072
1073 if (func->num != 1 && func->num != 2)
1074 return;
1075
1076 bus_if = dev_get_drvdata(&func->dev);
1077 if (bus_if) {
1078 sdiodev = bus_if->bus_priv.sdio;
1079 brcmf_sdiod_remove(sdiodev);
1080
1081 dev_set_drvdata(&sdiodev->func[1]->dev, NULL);
1082 dev_set_drvdata(&sdiodev->func[2]->dev, NULL);
1083
1084 kfree(bus_if);
1085 kfree(sdiodev->func[0]);
1086 kfree(sdiodev);
1087 }
1088
1089 brcmf_dbg(SDIO, "Exit\n");
1090}
1091
1092#ifdef CONFIG_PM_SLEEP
1093static int brcmf_ops_sdio_suspend(struct device *dev)
1094{
1095 mmc_pm_flag_t sdio_flags;
1096 struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1097 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
1098 int ret = 0;
1099
1100 brcmf_dbg(SDIO, "\n");
1101
1102 atomic_set(&sdiodev->suspend, true);
1103
1104 sdio_flags = sdio_get_host_pm_caps(sdiodev->func[1]);
1105 if (!(sdio_flags & MMC_PM_KEEP_POWER)) {
1106 brcmf_err("Host can't keep power while suspended\n");
1107 return -EINVAL;
1108 }
1109
1110 ret = sdio_set_host_pm_flags(sdiodev->func[1], MMC_PM_KEEP_POWER);
1111 if (ret) {
1112 brcmf_err("Failed to set pm_flags\n");
1113 return ret;
1114 }
1115
1116 brcmf_sdio_wd_timer(sdiodev->bus, 0);
1117
1118 return ret;
1119}
1120
1121static int brcmf_ops_sdio_resume(struct device *dev)
1122{
1123 struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1124 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
1125
1126 brcmf_sdio_wd_timer(sdiodev->bus, BRCMF_WD_POLL_MS);
1127 atomic_set(&sdiodev->suspend, false);
1128 return 0;
1129}
1130
1131static const struct dev_pm_ops brcmf_sdio_pm_ops = {
1132 .suspend = brcmf_ops_sdio_suspend,
1133 .resume = brcmf_ops_sdio_resume,
1134};
1135#endif /* CONFIG_PM_SLEEP */
1136
1137static struct sdio_driver brcmf_sdmmc_driver = {
1138 .probe = brcmf_ops_sdio_probe,
1139 .remove = brcmf_ops_sdio_remove,
1140 .name = BRCMFMAC_SDIO_PDATA_NAME,
1141 .id_table = brcmf_sdmmc_ids,
1142#ifdef CONFIG_PM_SLEEP
1143 .drv = {
1144 .pm = &brcmf_sdio_pm_ops,
1145 },
1146#endif /* CONFIG_PM_SLEEP */
1147};
1148
1149static int brcmf_sdio_pd_probe(struct platform_device *pdev)
1150{
1151 brcmf_dbg(SDIO, "Enter\n");
1152
1153 brcmfmac_sdio_pdata = dev_get_platdata(&pdev->dev);
1154
1155 if (brcmfmac_sdio_pdata->power_on)
1156 brcmfmac_sdio_pdata->power_on();
1157
1158 return 0;
1159}
1160
1161static int brcmf_sdio_pd_remove(struct platform_device *pdev)
1162{
1163 brcmf_dbg(SDIO, "Enter\n");
1164
1165 if (brcmfmac_sdio_pdata->power_off)
1166 brcmfmac_sdio_pdata->power_off();
1167
1168 sdio_unregister_driver(&brcmf_sdmmc_driver);
789 1169
790 return 0; 1170 return 0;
791} 1171}
792 1172
793void brcmf_sdio_wdtmr_enable(struct brcmf_sdio_dev *sdiodev, bool enable) 1173static struct platform_driver brcmf_sdio_pd = {
1174 .remove = brcmf_sdio_pd_remove,
1175 .driver = {
1176 .name = BRCMFMAC_SDIO_PDATA_NAME,
1177 .owner = THIS_MODULE,
1178 }
1179};
1180
1181void brcmf_sdio_register(void)
1182{
1183 int ret;
1184
1185 ret = sdio_register_driver(&brcmf_sdmmc_driver);
1186 if (ret)
1187 brcmf_err("sdio_register_driver failed: %d\n", ret);
1188}
1189
1190void brcmf_sdio_exit(void)
794{ 1191{
795 if (enable) 1192 brcmf_dbg(SDIO, "Enter\n");
796 brcmf_sdbrcm_wd_timer(sdiodev->bus, BRCMF_WD_POLL_MS); 1193
1194 if (brcmfmac_sdio_pdata)
1195 platform_driver_unregister(&brcmf_sdio_pd);
797 else 1196 else
798 brcmf_sdbrcm_wd_timer(sdiodev->bus, 0); 1197 sdio_unregister_driver(&brcmf_sdmmc_driver);
1198}
1199
1200void __init brcmf_sdio_init(void)
1201{
1202 int ret;
1203
1204 brcmf_dbg(SDIO, "Enter\n");
1205
1206 ret = platform_driver_probe(&brcmf_sdio_pd, brcmf_sdio_pd_probe);
1207 if (ret == -ENODEV)
1208 brcmf_dbg(SDIO, "No platform data available.\n");
799} 1209}
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh_sdmmc.c b/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh_sdmmc.c
deleted file mode 100644
index a511c27122b8..000000000000
--- a/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh_sdmmc.c
+++ /dev/null
@@ -1,552 +0,0 @@
1/*
2 * Copyright (c) 2010 Broadcom Corporation
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
11 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
13 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
14 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17#include <linux/types.h>
18#include <linux/netdevice.h>
19#include <linux/mmc/sdio.h>
20#include <linux/mmc/core.h>
21#include <linux/mmc/sdio_func.h>
22#include <linux/mmc/sdio_ids.h>
23#include <linux/mmc/card.h>
24#include <linux/mmc/host.h>
25#include <linux/suspend.h>
26#include <linux/errno.h>
27#include <linux/sched.h> /* request_irq() */
28#include <linux/module.h>
29#include <linux/platform_device.h>
30#include <linux/platform_data/brcmfmac-sdio.h>
31#include <net/cfg80211.h>
32
33#include <defs.h>
34#include <brcm_hw_ids.h>
35#include <brcmu_utils.h>
36#include <brcmu_wifi.h>
37#include "sdio_host.h"
38#include "sdio_chip.h"
39#include "dhd_dbg.h"
40#include "dhd_bus.h"
41
42#define SDIO_VENDOR_ID_BROADCOM 0x02d0
43
44#define DMA_ALIGN_MASK 0x03
45
46#define SDIO_FUNC1_BLOCKSIZE 64
47#define SDIO_FUNC2_BLOCKSIZE 512
48
49/* devices we support, null terminated */
50static const struct sdio_device_id brcmf_sdmmc_ids[] = {
51 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_43143)},
52 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_43241)},
53 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_4329)},
54 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_4330)},
55 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_4334)},
56 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM,
57 SDIO_DEVICE_ID_BROADCOM_4335_4339)},
58 { /* end: all zeroes */ },
59};
60MODULE_DEVICE_TABLE(sdio, brcmf_sdmmc_ids);
61
62static struct brcmfmac_sdio_platform_data *brcmfmac_sdio_pdata;
63
64
65bool
66brcmf_pm_resume_error(struct brcmf_sdio_dev *sdiodev)
67{
68 bool is_err = false;
69#ifdef CONFIG_PM_SLEEP
70 is_err = atomic_read(&sdiodev->suspend);
71#endif
72 return is_err;
73}
74
75void
76brcmf_pm_resume_wait(struct brcmf_sdio_dev *sdiodev, wait_queue_head_t *wq)
77{
78#ifdef CONFIG_PM_SLEEP
79 int retry = 0;
80 while (atomic_read(&sdiodev->suspend) && retry++ != 30)
81 wait_event_timeout(*wq, false, HZ/100);
82#endif
83}
84
85static inline int brcmf_sdioh_f0_write_byte(struct brcmf_sdio_dev *sdiodev,
86 uint regaddr, u8 *byte)
87{
88 struct sdio_func *sdfunc = sdiodev->func[0];
89 int err_ret;
90
91 /*
92 * Can only directly write to some F0 registers.
93 * Handle F2 enable/disable and Abort command
94 * as a special case.
95 */
96 if (regaddr == SDIO_CCCR_IOEx) {
97 sdfunc = sdiodev->func[2];
98 if (sdfunc) {
99 if (*byte & SDIO_FUNC_ENABLE_2) {
100 /* Enable Function 2 */
101 err_ret = sdio_enable_func(sdfunc);
102 if (err_ret)
103 brcmf_err("enable F2 failed:%d\n",
104 err_ret);
105 } else {
106 /* Disable Function 2 */
107 err_ret = sdio_disable_func(sdfunc);
108 if (err_ret)
109 brcmf_err("Disable F2 failed:%d\n",
110 err_ret);
111 }
112 } else {
113 err_ret = -ENOENT;
114 }
115 } else if ((regaddr == SDIO_CCCR_ABORT) ||
116 (regaddr == SDIO_CCCR_IENx)) {
117 sdfunc = kmemdup(sdiodev->func[0], sizeof(struct sdio_func),
118 GFP_KERNEL);
119 if (!sdfunc)
120 return -ENOMEM;
121 sdfunc->num = 0;
122 sdio_writeb(sdfunc, *byte, regaddr, &err_ret);
123 kfree(sdfunc);
124 } else if (regaddr < 0xF0) {
125 brcmf_err("F0 Wr:0x%02x: write disallowed\n", regaddr);
126 err_ret = -EPERM;
127 } else {
128 sdio_f0_writeb(sdfunc, *byte, regaddr, &err_ret);
129 }
130
131 return err_ret;
132}
133
134int brcmf_sdioh_request_byte(struct brcmf_sdio_dev *sdiodev, uint rw, uint func,
135 uint regaddr, u8 *byte)
136{
137 int err_ret;
138
139 brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x\n", rw, func, regaddr);
140
141 brcmf_pm_resume_wait(sdiodev, &sdiodev->request_byte_wait);
142 if (brcmf_pm_resume_error(sdiodev))
143 return -EIO;
144
145 if (rw && func == 0) {
146 /* handle F0 separately */
147 err_ret = brcmf_sdioh_f0_write_byte(sdiodev, regaddr, byte);
148 } else {
149 if (rw) /* CMD52 Write */
150 sdio_writeb(sdiodev->func[func], *byte, regaddr,
151 &err_ret);
152 else if (func == 0) {
153 *byte = sdio_f0_readb(sdiodev->func[func], regaddr,
154 &err_ret);
155 } else {
156 *byte = sdio_readb(sdiodev->func[func], regaddr,
157 &err_ret);
158 }
159 }
160
161 if (err_ret) {
162 /*
163 * SleepCSR register access can fail when
164 * waking up the device so reduce this noise
165 * in the logs.
166 */
167 if (regaddr != SBSDIO_FUNC1_SLEEPCSR)
168 brcmf_err("Failed to %s byte F%d:@0x%05x=%02x, Err: %d\n",
169 rw ? "write" : "read", func, regaddr, *byte,
170 err_ret);
171 else
172 brcmf_dbg(SDIO, "Failed to %s byte F%d:@0x%05x=%02x, Err: %d\n",
173 rw ? "write" : "read", func, regaddr, *byte,
174 err_ret);
175 }
176 return err_ret;
177}
178
179int brcmf_sdioh_request_word(struct brcmf_sdio_dev *sdiodev,
180 uint rw, uint func, uint addr, u32 *word,
181 uint nbytes)
182{
183 int err_ret = -EIO;
184
185 if (func == 0) {
186 brcmf_err("Only CMD52 allowed to F0\n");
187 return -EINVAL;
188 }
189
190 brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",
191 rw, func, addr, nbytes);
192
193 brcmf_pm_resume_wait(sdiodev, &sdiodev->request_word_wait);
194 if (brcmf_pm_resume_error(sdiodev))
195 return -EIO;
196
197 if (rw) { /* CMD52 Write */
198 if (nbytes == 4)
199 sdio_writel(sdiodev->func[func], *word, addr,
200 &err_ret);
201 else if (nbytes == 2)
202 sdio_writew(sdiodev->func[func], (*word & 0xFFFF),
203 addr, &err_ret);
204 else
205 brcmf_err("Invalid nbytes: %d\n", nbytes);
206 } else { /* CMD52 Read */
207 if (nbytes == 4)
208 *word = sdio_readl(sdiodev->func[func], addr, &err_ret);
209 else if (nbytes == 2)
210 *word = sdio_readw(sdiodev->func[func], addr,
211 &err_ret) & 0xFFFF;
212 else
213 brcmf_err("Invalid nbytes: %d\n", nbytes);
214 }
215
216 if (err_ret)
217 brcmf_err("Failed to %s word, Err: 0x%08x\n",
218 rw ? "write" : "read", err_ret);
219
220 return err_ret;
221}
222
223static int brcmf_sdioh_get_cisaddr(struct brcmf_sdio_dev *sdiodev, u32 regaddr)
224{
225 /* read 24 bits and return valid 17 bit addr */
226 int i, ret;
227 u32 scratch, regdata;
228 __le32 scratch_le;
229 u8 *ptr = (u8 *)&scratch_le;
230
231 for (i = 0; i < 3; i++) {
232 regdata = brcmf_sdio_regrl(sdiodev, regaddr, &ret);
233 if (ret != 0)
234 brcmf_err("Can't read!\n");
235
236 *ptr++ = (u8) regdata;
237 regaddr++;
238 }
239
240 /* Only the lower 17-bits are valid */
241 scratch = le32_to_cpu(scratch_le);
242 scratch &= 0x0001FFFF;
243 return scratch;
244}
245
246static int brcmf_sdioh_enablefuncs(struct brcmf_sdio_dev *sdiodev)
247{
248 int err_ret;
249 u32 fbraddr;
250 u8 func;
251
252 brcmf_dbg(SDIO, "\n");
253
254 /* Get the Card's common CIS address */
255 sdiodev->func_cis_ptr[0] = brcmf_sdioh_get_cisaddr(sdiodev,
256 SDIO_CCCR_CIS);
257 brcmf_dbg(SDIO, "Card's Common CIS Ptr = 0x%x\n",
258 sdiodev->func_cis_ptr[0]);
259
260 /* Get the Card's function CIS (for each function) */
261 for (fbraddr = SDIO_FBR_BASE(1), func = 1;
262 func <= sdiodev->num_funcs; func++, fbraddr += SDIOD_FBR_SIZE) {
263 sdiodev->func_cis_ptr[func] =
264 brcmf_sdioh_get_cisaddr(sdiodev, SDIO_FBR_CIS + fbraddr);
265 brcmf_dbg(SDIO, "Function %d CIS Ptr = 0x%x\n",
266 func, sdiodev->func_cis_ptr[func]);
267 }
268
269 /* Enable Function 1 */
270 err_ret = sdio_enable_func(sdiodev->func[1]);
271 if (err_ret)
272 brcmf_err("Failed to enable F1 Err: 0x%08x\n", err_ret);
273
274 return false;
275}
276
277/*
278 * Public entry points & extern's
279 */
280int brcmf_sdioh_attach(struct brcmf_sdio_dev *sdiodev)
281{
282 int err_ret = 0;
283 struct mmc_host *host;
284 struct sdio_func *func;
285 uint max_blocks;
286
287 brcmf_dbg(SDIO, "\n");
288
289 sdiodev->num_funcs = 2;
290
291 sdio_claim_host(sdiodev->func[1]);
292
293 err_ret = sdio_set_block_size(sdiodev->func[1], SDIO_FUNC1_BLOCKSIZE);
294 if (err_ret) {
295 brcmf_err("Failed to set F1 blocksize\n");
296 goto out;
297 }
298
299 err_ret = sdio_set_block_size(sdiodev->func[2], SDIO_FUNC2_BLOCKSIZE);
300 if (err_ret) {
301 brcmf_err("Failed to set F2 blocksize\n");
302 goto out;
303 }
304
305 brcmf_sdioh_enablefuncs(sdiodev);
306
307 /*
308 * determine host related variables after brcmf_sdio_probe()
309 * as func->cur_blksize is properly set and F2 init has been
310 * completed successfully.
311 */
312 func = sdiodev->func[2];
313 host = func->card->host;
314 sdiodev->sg_support = host->max_segs > 1;
315 max_blocks = min_t(uint, host->max_blk_count, 511u);
316 sdiodev->max_request_size = min_t(uint, host->max_req_size,
317 max_blocks * func->cur_blksize);
318 sdiodev->max_segment_count = min_t(uint, host->max_segs,
319 SG_MAX_SINGLE_ALLOC);
320 sdiodev->max_segment_size = host->max_seg_size;
321out:
322 sdio_release_host(sdiodev->func[1]);
323 brcmf_dbg(SDIO, "Done\n");
324 return err_ret;
325}
326
327void brcmf_sdioh_detach(struct brcmf_sdio_dev *sdiodev)
328{
329 brcmf_dbg(SDIO, "\n");
330
331 /* Disable Function 2 */
332 sdio_claim_host(sdiodev->func[2]);
333 sdio_disable_func(sdiodev->func[2]);
334 sdio_release_host(sdiodev->func[2]);
335
336 /* Disable Function 1 */
337 sdio_claim_host(sdiodev->func[1]);
338 sdio_disable_func(sdiodev->func[1]);
339 sdio_release_host(sdiodev->func[1]);
340
341}
342
343static int brcmf_ops_sdio_probe(struct sdio_func *func,
344 const struct sdio_device_id *id)
345{
346 int err;
347 struct brcmf_sdio_dev *sdiodev;
348 struct brcmf_bus *bus_if;
349
350 brcmf_dbg(SDIO, "Enter\n");
351 brcmf_dbg(SDIO, "Class=%x\n", func->class);
352 brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
353 brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
354 brcmf_dbg(SDIO, "Function#: %d\n", func->num);
355
356 /* Consume func num 1 but dont do anything with it. */
357 if (func->num == 1)
358 return 0;
359
360 /* Ignore anything but func 2 */
361 if (func->num != 2)
362 return -ENODEV;
363
364 bus_if = kzalloc(sizeof(struct brcmf_bus), GFP_KERNEL);
365 if (!bus_if)
366 return -ENOMEM;
367 sdiodev = kzalloc(sizeof(struct brcmf_sdio_dev), GFP_KERNEL);
368 if (!sdiodev) {
369 kfree(bus_if);
370 return -ENOMEM;
371 }
372
373 sdiodev->func[0] = func->card->sdio_func[0];
374 sdiodev->func[1] = func->card->sdio_func[0];
375 sdiodev->func[2] = func;
376
377 sdiodev->bus_if = bus_if;
378 bus_if->bus_priv.sdio = sdiodev;
379 dev_set_drvdata(&func->dev, bus_if);
380 dev_set_drvdata(&sdiodev->func[1]->dev, bus_if);
381 sdiodev->dev = &sdiodev->func[1]->dev;
382 sdiodev->pdata = brcmfmac_sdio_pdata;
383
384 atomic_set(&sdiodev->suspend, false);
385 init_waitqueue_head(&sdiodev->request_byte_wait);
386 init_waitqueue_head(&sdiodev->request_word_wait);
387 init_waitqueue_head(&sdiodev->request_buffer_wait);
388
389 brcmf_dbg(SDIO, "F2 found, calling brcmf_sdio_probe...\n");
390 err = brcmf_sdio_probe(sdiodev);
391 if (err) {
392 brcmf_err("F2 error, probe failed %d...\n", err);
393 goto fail;
394 }
395
396 brcmf_dbg(SDIO, "F2 init completed...\n");
397 return 0;
398
399fail:
400 dev_set_drvdata(&func->dev, NULL);
401 dev_set_drvdata(&sdiodev->func[1]->dev, NULL);
402 kfree(sdiodev);
403 kfree(bus_if);
404 return err;
405}
406
407static void brcmf_ops_sdio_remove(struct sdio_func *func)
408{
409 struct brcmf_bus *bus_if;
410 struct brcmf_sdio_dev *sdiodev;
411
412 brcmf_dbg(SDIO, "Enter\n");
413 brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
414 brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
415 brcmf_dbg(SDIO, "Function: %d\n", func->num);
416
417 if (func->num != 1 && func->num != 2)
418 return;
419
420 bus_if = dev_get_drvdata(&func->dev);
421 if (bus_if) {
422 sdiodev = bus_if->bus_priv.sdio;
423 brcmf_sdio_remove(sdiodev);
424
425 dev_set_drvdata(&sdiodev->func[1]->dev, NULL);
426 dev_set_drvdata(&sdiodev->func[2]->dev, NULL);
427
428 kfree(bus_if);
429 kfree(sdiodev);
430 }
431
432 brcmf_dbg(SDIO, "Exit\n");
433}
434
435#ifdef CONFIG_PM_SLEEP
436static int brcmf_sdio_suspend(struct device *dev)
437{
438 mmc_pm_flag_t sdio_flags;
439 struct brcmf_bus *bus_if = dev_get_drvdata(dev);
440 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
441 int ret = 0;
442
443 brcmf_dbg(SDIO, "\n");
444
445 atomic_set(&sdiodev->suspend, true);
446
447 sdio_flags = sdio_get_host_pm_caps(sdiodev->func[1]);
448 if (!(sdio_flags & MMC_PM_KEEP_POWER)) {
449 brcmf_err("Host can't keep power while suspended\n");
450 return -EINVAL;
451 }
452
453 ret = sdio_set_host_pm_flags(sdiodev->func[1], MMC_PM_KEEP_POWER);
454 if (ret) {
455 brcmf_err("Failed to set pm_flags\n");
456 return ret;
457 }
458
459 brcmf_sdio_wdtmr_enable(sdiodev, false);
460
461 return ret;
462}
463
464static int brcmf_sdio_resume(struct device *dev)
465{
466 struct brcmf_bus *bus_if = dev_get_drvdata(dev);
467 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
468
469 brcmf_sdio_wdtmr_enable(sdiodev, true);
470 atomic_set(&sdiodev->suspend, false);
471 return 0;
472}
473
474static const struct dev_pm_ops brcmf_sdio_pm_ops = {
475 .suspend = brcmf_sdio_suspend,
476 .resume = brcmf_sdio_resume,
477};
478#endif /* CONFIG_PM_SLEEP */
479
480static struct sdio_driver brcmf_sdmmc_driver = {
481 .probe = brcmf_ops_sdio_probe,
482 .remove = brcmf_ops_sdio_remove,
483 .name = BRCMFMAC_SDIO_PDATA_NAME,
484 .id_table = brcmf_sdmmc_ids,
485#ifdef CONFIG_PM_SLEEP
486 .drv = {
487 .pm = &brcmf_sdio_pm_ops,
488 },
489#endif /* CONFIG_PM_SLEEP */
490};
491
492static int brcmf_sdio_pd_probe(struct platform_device *pdev)
493{
494 brcmf_dbg(SDIO, "Enter\n");
495
496 brcmfmac_sdio_pdata = dev_get_platdata(&pdev->dev);
497
498 if (brcmfmac_sdio_pdata->power_on)
499 brcmfmac_sdio_pdata->power_on();
500
501 return 0;
502}
503
504static int brcmf_sdio_pd_remove(struct platform_device *pdev)
505{
506 brcmf_dbg(SDIO, "Enter\n");
507
508 if (brcmfmac_sdio_pdata->power_off)
509 brcmfmac_sdio_pdata->power_off();
510
511 sdio_unregister_driver(&brcmf_sdmmc_driver);
512
513 return 0;
514}
515
516static struct platform_driver brcmf_sdio_pd = {
517 .remove = brcmf_sdio_pd_remove,
518 .driver = {
519 .name = BRCMFMAC_SDIO_PDATA_NAME,
520 .owner = THIS_MODULE,
521 }
522};
523
524void brcmf_sdio_register(void)
525{
526 int ret;
527
528 ret = sdio_register_driver(&brcmf_sdmmc_driver);
529 if (ret)
530 brcmf_err("sdio_register_driver failed: %d\n", ret);
531}
532
533void brcmf_sdio_exit(void)
534{
535 brcmf_dbg(SDIO, "Enter\n");
536
537 if (brcmfmac_sdio_pdata)
538 platform_driver_unregister(&brcmf_sdio_pd);
539 else
540 sdio_unregister_driver(&brcmf_sdmmc_driver);
541}
542
543void __init brcmf_sdio_init(void)
544{
545 int ret;
546
547 brcmf_dbg(SDIO, "Enter\n");
548
549 ret = platform_driver_probe(&brcmf_sdio_pd, brcmf_sdio_pd_probe);
550 if (ret == -ENODEV)
551 brcmf_dbg(SDIO, "No platform data available.\n");
552}
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/dhd_bus.h b/drivers/net/wireless/brcm80211/brcmfmac/dhd_bus.h
index 6a54905528be..5c12a07673fa 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/dhd_bus.h
+++ b/drivers/net/wireless/brcm80211/brcmfmac/dhd_bus.h
@@ -24,6 +24,12 @@ enum brcmf_bus_state {
24 BRCMF_BUS_DATA /* Ready for frame transfers */ 24 BRCMF_BUS_DATA /* Ready for frame transfers */
25}; 25};
26 26
27/* The level of bus communication with the dongle */
28enum brcmf_bus_protocol_type {
29 BRCMF_PROTO_BCDC,
30 BRCMF_PROTO_MSGBUF
31};
32
27struct brcmf_bus_dcmd { 33struct brcmf_bus_dcmd {
28 char *name; 34 char *name;
29 char *param; 35 char *param;
@@ -65,6 +71,7 @@ struct brcmf_bus_ops {
65 * struct brcmf_bus - interface structure between common and bus layer 71 * struct brcmf_bus - interface structure between common and bus layer
66 * 72 *
67 * @bus_priv: pointer to private bus device. 73 * @bus_priv: pointer to private bus device.
74 * @proto_type: protocol type, bcdc or msgbuf
68 * @dev: device pointer of bus device. 75 * @dev: device pointer of bus device.
69 * @drvr: public driver information. 76 * @drvr: public driver information.
70 * @state: operational state of the bus interface. 77 * @state: operational state of the bus interface.
@@ -80,6 +87,7 @@ struct brcmf_bus {
80 struct brcmf_sdio_dev *sdio; 87 struct brcmf_sdio_dev *sdio;
81 struct brcmf_usbdev *usb; 88 struct brcmf_usbdev *usb;
82 } bus_priv; 89 } bus_priv;
90 enum brcmf_bus_protocol_type proto_type;
83 struct device *dev; 91 struct device *dev;
84 struct brcmf_pub *drvr; 92 struct brcmf_pub *drvr;
85 enum brcmf_bus_state state; 93 enum brcmf_bus_state state;
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c b/drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c
index 0f95f3e79c10..f214510e3bee 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c
@@ -260,9 +260,6 @@ struct rte_console {
260#define MAX_HDR_READ (1 << 6) 260#define MAX_HDR_READ (1 << 6)
261#define MAX_RX_DATASZ 2048 261#define MAX_RX_DATASZ 2048
262 262
263/* Maximum milliseconds to wait for F2 to come up */
264#define BRCMF_WAIT_F2RDY 3000
265
266/* Bump up limit on waiting for HT to account for first startup; 263/* Bump up limit on waiting for HT to account for first startup;
267 * if the image is doing a CRC calculation before programming the PMU 264 * if the image is doing a CRC calculation before programming the PMU
268 * for HT availability, it could take a couple hundred ms more, so 265 * for HT availability, it could take a couple hundred ms more, so
@@ -559,7 +556,7 @@ static const struct brcmf_firmware_names brcmf_fwname_data[] = {
559}; 556};
560 557
561 558
562static const struct firmware *brcmf_sdbrcm_get_fw(struct brcmf_sdio *bus, 559static const struct firmware *brcmf_sdio_get_fw(struct brcmf_sdio *bus,
563 enum brcmf_firmware_type type) 560 enum brcmf_firmware_type type)
564{ 561{
565 const struct firmware *fw; 562 const struct firmware *fw;
@@ -624,8 +621,8 @@ r_sdreg32(struct brcmf_sdio *bus, u32 *regvar, u32 offset)
624 u8 idx = brcmf_sdio_chip_getinfidx(bus->ci, BCMA_CORE_SDIO_DEV); 621 u8 idx = brcmf_sdio_chip_getinfidx(bus->ci, BCMA_CORE_SDIO_DEV);
625 int ret; 622 int ret;
626 623
627 *regvar = brcmf_sdio_regrl(bus->sdiodev, 624 *regvar = brcmf_sdiod_regrl(bus->sdiodev,
628 bus->ci->c_inf[idx].base + offset, &ret); 625 bus->ci->c_inf[idx].base + offset, &ret);
629 626
630 return ret; 627 return ret;
631} 628}
@@ -636,15 +633,15 @@ w_sdreg32(struct brcmf_sdio *bus, u32 regval, u32 reg_offset)
636 u8 idx = brcmf_sdio_chip_getinfidx(bus->ci, BCMA_CORE_SDIO_DEV); 633 u8 idx = brcmf_sdio_chip_getinfidx(bus->ci, BCMA_CORE_SDIO_DEV);
637 int ret; 634 int ret;
638 635
639 brcmf_sdio_regwl(bus->sdiodev, 636 brcmf_sdiod_regwl(bus->sdiodev,
640 bus->ci->c_inf[idx].base + reg_offset, 637 bus->ci->c_inf[idx].base + reg_offset,
641 regval, &ret); 638 regval, &ret);
642 639
643 return ret; 640 return ret;
644} 641}
645 642
646static int 643static int
647brcmf_sdbrcm_kso_control(struct brcmf_sdio *bus, bool on) 644brcmf_sdio_kso_control(struct brcmf_sdio *bus, bool on)
648{ 645{
649 u8 wr_val = 0, rd_val, cmp_val, bmask; 646 u8 wr_val = 0, rd_val, cmp_val, bmask;
650 int err = 0; 647 int err = 0;
@@ -654,8 +651,8 @@ brcmf_sdbrcm_kso_control(struct brcmf_sdio *bus, bool on)
654 651
655 wr_val = (on << SBSDIO_FUNC1_SLEEPCSR_KSO_SHIFT); 652 wr_val = (on << SBSDIO_FUNC1_SLEEPCSR_KSO_SHIFT);
656 /* 1st KSO write goes to AOS wake up core if device is asleep */ 653 /* 1st KSO write goes to AOS wake up core if device is asleep */
657 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_SLEEPCSR, 654 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_SLEEPCSR,
658 wr_val, &err); 655 wr_val, &err);
659 if (err) { 656 if (err) {
660 brcmf_err("SDIO_AOS KSO write error: %d\n", err); 657 brcmf_err("SDIO_AOS KSO write error: %d\n", err);
661 return err; 658 return err;
@@ -685,15 +682,15 @@ brcmf_sdbrcm_kso_control(struct brcmf_sdio *bus, bool on)
685 * just one write attempt may fail, 682 * just one write attempt may fail,
686 * read it back until it matches written value 683 * read it back until it matches written value
687 */ 684 */
688 rd_val = brcmf_sdio_regrb(bus->sdiodev, SBSDIO_FUNC1_SLEEPCSR, 685 rd_val = brcmf_sdiod_regrb(bus->sdiodev, SBSDIO_FUNC1_SLEEPCSR,
689 &err); 686 &err);
690 if (((rd_val & bmask) == cmp_val) && !err) 687 if (((rd_val & bmask) == cmp_val) && !err)
691 break; 688 break;
692 brcmf_dbg(SDIO, "KSO wr/rd retry:%d (max: %d) ERR:%x\n", 689 brcmf_dbg(SDIO, "KSO wr/rd retry:%d (max: %d) ERR:%x\n",
693 try_cnt, MAX_KSO_ATTEMPTS, err); 690 try_cnt, MAX_KSO_ATTEMPTS, err);
694 udelay(KSO_WAIT_US); 691 udelay(KSO_WAIT_US);
695 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_SLEEPCSR, 692 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_SLEEPCSR,
696 wr_val, &err); 693 wr_val, &err);
697 } while (try_cnt++ < MAX_KSO_ATTEMPTS); 694 } while (try_cnt++ < MAX_KSO_ATTEMPTS);
698 695
699 return err; 696 return err;
@@ -704,7 +701,7 @@ brcmf_sdbrcm_kso_control(struct brcmf_sdio *bus, bool on)
704#define HOSTINTMASK (I_HMB_SW_MASK | I_CHIPACTIVE) 701#define HOSTINTMASK (I_HMB_SW_MASK | I_CHIPACTIVE)
705 702
706/* Turn backplane clock on or off */ 703/* Turn backplane clock on or off */
707static int brcmf_sdbrcm_htclk(struct brcmf_sdio *bus, bool on, bool pendok) 704static int brcmf_sdio_htclk(struct brcmf_sdio *bus, bool on, bool pendok)
708{ 705{
709 int err; 706 int err;
710 u8 clkctl, clkreq, devctl; 707 u8 clkctl, clkreq, devctl;
@@ -724,16 +721,16 @@ static int brcmf_sdbrcm_htclk(struct brcmf_sdio *bus, bool on, bool pendok)
724 clkreq = 721 clkreq =
725 bus->alp_only ? SBSDIO_ALP_AVAIL_REQ : SBSDIO_HT_AVAIL_REQ; 722 bus->alp_only ? SBSDIO_ALP_AVAIL_REQ : SBSDIO_HT_AVAIL_REQ;
726 723
727 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, 724 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR,
728 clkreq, &err); 725 clkreq, &err);
729 if (err) { 726 if (err) {
730 brcmf_err("HT Avail request error: %d\n", err); 727 brcmf_err("HT Avail request error: %d\n", err);
731 return -EBADE; 728 return -EBADE;
732 } 729 }
733 730
734 /* Check current status */ 731 /* Check current status */
735 clkctl = brcmf_sdio_regrb(bus->sdiodev, 732 clkctl = brcmf_sdiod_regrb(bus->sdiodev,
736 SBSDIO_FUNC1_CHIPCLKCSR, &err); 733 SBSDIO_FUNC1_CHIPCLKCSR, &err);
737 if (err) { 734 if (err) {
738 brcmf_err("HT Avail read error: %d\n", err); 735 brcmf_err("HT Avail read error: %d\n", err);
739 return -EBADE; 736 return -EBADE;
@@ -742,8 +739,8 @@ static int brcmf_sdbrcm_htclk(struct brcmf_sdio *bus, bool on, bool pendok)
742 /* Go to pending and await interrupt if appropriate */ 739 /* Go to pending and await interrupt if appropriate */
743 if (!SBSDIO_CLKAV(clkctl, bus->alp_only) && pendok) { 740 if (!SBSDIO_CLKAV(clkctl, bus->alp_only) && pendok) {
744 /* Allow only clock-available interrupt */ 741 /* Allow only clock-available interrupt */
745 devctl = brcmf_sdio_regrb(bus->sdiodev, 742 devctl = brcmf_sdiod_regrb(bus->sdiodev,
746 SBSDIO_DEVICE_CTL, &err); 743 SBSDIO_DEVICE_CTL, &err);
747 if (err) { 744 if (err) {
748 brcmf_err("Devctl error setting CA: %d\n", 745 brcmf_err("Devctl error setting CA: %d\n",
749 err); 746 err);
@@ -751,28 +748,28 @@ static int brcmf_sdbrcm_htclk(struct brcmf_sdio *bus, bool on, bool pendok)
751 } 748 }
752 749
753 devctl |= SBSDIO_DEVCTL_CA_INT_ONLY; 750 devctl |= SBSDIO_DEVCTL_CA_INT_ONLY;
754 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_DEVICE_CTL, 751 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_DEVICE_CTL,
755 devctl, &err); 752 devctl, &err);
756 brcmf_dbg(SDIO, "CLKCTL: set PENDING\n"); 753 brcmf_dbg(SDIO, "CLKCTL: set PENDING\n");
757 bus->clkstate = CLK_PENDING; 754 bus->clkstate = CLK_PENDING;
758 755
759 return 0; 756 return 0;
760 } else if (bus->clkstate == CLK_PENDING) { 757 } else if (bus->clkstate == CLK_PENDING) {
761 /* Cancel CA-only interrupt filter */ 758 /* Cancel CA-only interrupt filter */
762 devctl = brcmf_sdio_regrb(bus->sdiodev, 759 devctl = brcmf_sdiod_regrb(bus->sdiodev,
763 SBSDIO_DEVICE_CTL, &err); 760 SBSDIO_DEVICE_CTL, &err);
764 devctl &= ~SBSDIO_DEVCTL_CA_INT_ONLY; 761 devctl &= ~SBSDIO_DEVCTL_CA_INT_ONLY;
765 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_DEVICE_CTL, 762 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_DEVICE_CTL,
766 devctl, &err); 763 devctl, &err);
767 } 764 }
768 765
769 /* Otherwise, wait here (polling) for HT Avail */ 766 /* Otherwise, wait here (polling) for HT Avail */
770 timeout = jiffies + 767 timeout = jiffies +
771 msecs_to_jiffies(PMU_MAX_TRANSITION_DLY/1000); 768 msecs_to_jiffies(PMU_MAX_TRANSITION_DLY/1000);
772 while (!SBSDIO_CLKAV(clkctl, bus->alp_only)) { 769 while (!SBSDIO_CLKAV(clkctl, bus->alp_only)) {
773 clkctl = brcmf_sdio_regrb(bus->sdiodev, 770 clkctl = brcmf_sdiod_regrb(bus->sdiodev,
774 SBSDIO_FUNC1_CHIPCLKCSR, 771 SBSDIO_FUNC1_CHIPCLKCSR,
775 &err); 772 &err);
776 if (time_after(jiffies, timeout)) 773 if (time_after(jiffies, timeout))
777 break; 774 break;
778 else 775 else
@@ -805,16 +802,16 @@ static int brcmf_sdbrcm_htclk(struct brcmf_sdio *bus, bool on, bool pendok)
805 802
806 if (bus->clkstate == CLK_PENDING) { 803 if (bus->clkstate == CLK_PENDING) {
807 /* Cancel CA-only interrupt filter */ 804 /* Cancel CA-only interrupt filter */
808 devctl = brcmf_sdio_regrb(bus->sdiodev, 805 devctl = brcmf_sdiod_regrb(bus->sdiodev,
809 SBSDIO_DEVICE_CTL, &err); 806 SBSDIO_DEVICE_CTL, &err);
810 devctl &= ~SBSDIO_DEVCTL_CA_INT_ONLY; 807 devctl &= ~SBSDIO_DEVCTL_CA_INT_ONLY;
811 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_DEVICE_CTL, 808 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_DEVICE_CTL,
812 devctl, &err); 809 devctl, &err);
813 } 810 }
814 811
815 bus->clkstate = CLK_SDONLY; 812 bus->clkstate = CLK_SDONLY;
816 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, 813 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR,
817 clkreq, &err); 814 clkreq, &err);
818 brcmf_dbg(SDIO, "CLKCTL: turned OFF\n"); 815 brcmf_dbg(SDIO, "CLKCTL: turned OFF\n");
819 if (err) { 816 if (err) {
820 brcmf_err("Failed access turning clock off: %d\n", 817 brcmf_err("Failed access turning clock off: %d\n",
@@ -826,7 +823,7 @@ static int brcmf_sdbrcm_htclk(struct brcmf_sdio *bus, bool on, bool pendok)
826} 823}
827 824
828/* Change idle/active SD state */ 825/* Change idle/active SD state */
829static int brcmf_sdbrcm_sdclk(struct brcmf_sdio *bus, bool on) 826static int brcmf_sdio_sdclk(struct brcmf_sdio *bus, bool on)
830{ 827{
831 brcmf_dbg(SDIO, "Enter\n"); 828 brcmf_dbg(SDIO, "Enter\n");
832 829
@@ -839,7 +836,7 @@ static int brcmf_sdbrcm_sdclk(struct brcmf_sdio *bus, bool on)
839} 836}
840 837
841/* Transition SD and backplane clock readiness */ 838/* Transition SD and backplane clock readiness */
842static int brcmf_sdbrcm_clkctl(struct brcmf_sdio *bus, uint target, bool pendok) 839static int brcmf_sdio_clkctl(struct brcmf_sdio *bus, uint target, bool pendok)
843{ 840{
844#ifdef DEBUG 841#ifdef DEBUG
845 uint oldstate = bus->clkstate; 842 uint oldstate = bus->clkstate;
@@ -850,7 +847,7 @@ static int brcmf_sdbrcm_clkctl(struct brcmf_sdio *bus, uint target, bool pendok)
850 /* Early exit if we're already there */ 847 /* Early exit if we're already there */
851 if (bus->clkstate == target) { 848 if (bus->clkstate == target) {
852 if (target == CLK_AVAIL) { 849 if (target == CLK_AVAIL) {
853 brcmf_sdbrcm_wd_timer(bus, BRCMF_WD_POLL_MS); 850 brcmf_sdio_wd_timer(bus, BRCMF_WD_POLL_MS);
854 bus->activity = true; 851 bus->activity = true;
855 } 852 }
856 return 0; 853 return 0;
@@ -860,32 +857,32 @@ static int brcmf_sdbrcm_clkctl(struct brcmf_sdio *bus, uint target, bool pendok)
860 case CLK_AVAIL: 857 case CLK_AVAIL:
861 /* Make sure SD clock is available */ 858 /* Make sure SD clock is available */
862 if (bus->clkstate == CLK_NONE) 859 if (bus->clkstate == CLK_NONE)
863 brcmf_sdbrcm_sdclk(bus, true); 860 brcmf_sdio_sdclk(bus, true);
864 /* Now request HT Avail on the backplane */ 861 /* Now request HT Avail on the backplane */
865 brcmf_sdbrcm_htclk(bus, true, pendok); 862 brcmf_sdio_htclk(bus, true, pendok);
866 brcmf_sdbrcm_wd_timer(bus, BRCMF_WD_POLL_MS); 863 brcmf_sdio_wd_timer(bus, BRCMF_WD_POLL_MS);
867 bus->activity = true; 864 bus->activity = true;
868 break; 865 break;
869 866
870 case CLK_SDONLY: 867 case CLK_SDONLY:
871 /* Remove HT request, or bring up SD clock */ 868 /* Remove HT request, or bring up SD clock */
872 if (bus->clkstate == CLK_NONE) 869 if (bus->clkstate == CLK_NONE)
873 brcmf_sdbrcm_sdclk(bus, true); 870 brcmf_sdio_sdclk(bus, true);
874 else if (bus->clkstate == CLK_AVAIL) 871 else if (bus->clkstate == CLK_AVAIL)
875 brcmf_sdbrcm_htclk(bus, false, false); 872 brcmf_sdio_htclk(bus, false, false);
876 else 873 else
877 brcmf_err("request for %d -> %d\n", 874 brcmf_err("request for %d -> %d\n",
878 bus->clkstate, target); 875 bus->clkstate, target);
879 brcmf_sdbrcm_wd_timer(bus, BRCMF_WD_POLL_MS); 876 brcmf_sdio_wd_timer(bus, BRCMF_WD_POLL_MS);
880 break; 877 break;
881 878
882 case CLK_NONE: 879 case CLK_NONE:
883 /* Make sure to remove HT request */ 880 /* Make sure to remove HT request */
884 if (bus->clkstate == CLK_AVAIL) 881 if (bus->clkstate == CLK_AVAIL)
885 brcmf_sdbrcm_htclk(bus, false, false); 882 brcmf_sdio_htclk(bus, false, false);
886 /* Now remove the SD clock */ 883 /* Now remove the SD clock */
887 brcmf_sdbrcm_sdclk(bus, false); 884 brcmf_sdio_sdclk(bus, false);
888 brcmf_sdbrcm_wd_timer(bus, 0); 885 brcmf_sdio_wd_timer(bus, 0);
889 break; 886 break;
890 } 887 }
891#ifdef DEBUG 888#ifdef DEBUG
@@ -896,7 +893,7 @@ static int brcmf_sdbrcm_clkctl(struct brcmf_sdio *bus, uint target, bool pendok)
896} 893}
897 894
898static int 895static int
899brcmf_sdbrcm_bus_sleep(struct brcmf_sdio *bus, bool sleep, bool pendok) 896brcmf_sdio_bus_sleep(struct brcmf_sdio *bus, bool sleep, bool pendok)
900{ 897{
901 int err = 0; 898 int err = 0;
902 brcmf_dbg(TRACE, "Enter\n"); 899 brcmf_dbg(TRACE, "Enter\n");
@@ -919,13 +916,13 @@ brcmf_sdbrcm_bus_sleep(struct brcmf_sdio *bus, bool sleep, bool pendok)
919 brcmu_pktq_mlen(&bus->txq, ~bus->flowcontrol) && 916 brcmu_pktq_mlen(&bus->txq, ~bus->flowcontrol) &&
920 data_ok(bus))) 917 data_ok(bus)))
921 return -EBUSY; 918 return -EBUSY;
922 err = brcmf_sdbrcm_kso_control(bus, false); 919 err = brcmf_sdio_kso_control(bus, false);
923 /* disable watchdog */ 920 /* disable watchdog */
924 if (!err) 921 if (!err)
925 brcmf_sdbrcm_wd_timer(bus, 0); 922 brcmf_sdio_wd_timer(bus, 0);
926 } else { 923 } else {
927 bus->idlecount = 0; 924 bus->idlecount = 0;
928 err = brcmf_sdbrcm_kso_control(bus, true); 925 err = brcmf_sdio_kso_control(bus, true);
929 } 926 }
930 if (!err) { 927 if (!err) {
931 /* Change state */ 928 /* Change state */
@@ -943,16 +940,16 @@ end:
943 /* control clocks */ 940 /* control clocks */
944 if (sleep) { 941 if (sleep) {
945 if (!bus->sr_enabled) 942 if (!bus->sr_enabled)
946 brcmf_sdbrcm_clkctl(bus, CLK_NONE, pendok); 943 brcmf_sdio_clkctl(bus, CLK_NONE, pendok);
947 } else { 944 } else {
948 brcmf_sdbrcm_clkctl(bus, CLK_AVAIL, pendok); 945 brcmf_sdio_clkctl(bus, CLK_AVAIL, pendok);
949 } 946 }
950 947
951 return err; 948 return err;
952 949
953} 950}
954 951
955static u32 brcmf_sdbrcm_hostmail(struct brcmf_sdio *bus) 952static u32 brcmf_sdio_hostmail(struct brcmf_sdio *bus)
956{ 953{
957 u32 intstatus = 0; 954 u32 intstatus = 0;
958 u32 hmb_data; 955 u32 hmb_data;
@@ -1028,7 +1025,7 @@ static u32 brcmf_sdbrcm_hostmail(struct brcmf_sdio *bus)
1028 return intstatus; 1025 return intstatus;
1029} 1026}
1030 1027
1031static void brcmf_sdbrcm_rxfail(struct brcmf_sdio *bus, bool abort, bool rtx) 1028static void brcmf_sdio_rxfail(struct brcmf_sdio *bus, bool abort, bool rtx)
1032{ 1029{
1033 uint retries = 0; 1030 uint retries = 0;
1034 u16 lastrbc; 1031 u16 lastrbc;
@@ -1040,18 +1037,18 @@ static void brcmf_sdbrcm_rxfail(struct brcmf_sdio *bus, bool abort, bool rtx)
1040 rtx ? ", send NAK" : ""); 1037 rtx ? ", send NAK" : "");
1041 1038
1042 if (abort) 1039 if (abort)
1043 brcmf_sdcard_abort(bus->sdiodev, SDIO_FUNC_2); 1040 brcmf_sdiod_abort(bus->sdiodev, SDIO_FUNC_2);
1044 1041
1045 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_FRAMECTRL, 1042 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_FRAMECTRL,
1046 SFC_RF_TERM, &err); 1043 SFC_RF_TERM, &err);
1047 bus->sdcnt.f1regdata++; 1044 bus->sdcnt.f1regdata++;
1048 1045
1049 /* Wait until the packet has been flushed (device/FIFO stable) */ 1046 /* Wait until the packet has been flushed (device/FIFO stable) */
1050 for (lastrbc = retries = 0xffff; retries > 0; retries--) { 1047 for (lastrbc = retries = 0xffff; retries > 0; retries--) {
1051 hi = brcmf_sdio_regrb(bus->sdiodev, 1048 hi = brcmf_sdiod_regrb(bus->sdiodev,
1052 SBSDIO_FUNC1_RFRAMEBCHI, &err); 1049 SBSDIO_FUNC1_RFRAMEBCHI, &err);
1053 lo = brcmf_sdio_regrb(bus->sdiodev, 1050 lo = brcmf_sdiod_regrb(bus->sdiodev,
1054 SBSDIO_FUNC1_RFRAMEBCLO, &err); 1051 SBSDIO_FUNC1_RFRAMEBCLO, &err);
1055 bus->sdcnt.f1regdata += 2; 1052 bus->sdcnt.f1regdata += 2;
1056 1053
1057 if ((hi == 0) && (lo == 0)) 1054 if ((hi == 0) && (lo == 0))
@@ -1088,7 +1085,7 @@ static void brcmf_sdbrcm_rxfail(struct brcmf_sdio *bus, bool abort, bool rtx)
1088} 1085}
1089 1086
1090/* return total length of buffer chain */ 1087/* return total length of buffer chain */
1091static uint brcmf_sdbrcm_glom_len(struct brcmf_sdio *bus) 1088static uint brcmf_sdio_glom_len(struct brcmf_sdio *bus)
1092{ 1089{
1093 struct sk_buff *p; 1090 struct sk_buff *p;
1094 uint total; 1091 uint total;
@@ -1099,7 +1096,7 @@ static uint brcmf_sdbrcm_glom_len(struct brcmf_sdio *bus)
1099 return total; 1096 return total;
1100} 1097}
1101 1098
1102static void brcmf_sdbrcm_free_glom(struct brcmf_sdio *bus) 1099static void brcmf_sdio_free_glom(struct brcmf_sdio *bus)
1103{ 1100{
1104 struct sk_buff *cur, *next; 1101 struct sk_buff *cur, *next;
1105 1102
@@ -1187,7 +1184,7 @@ static int brcmf_sdio_hdparse(struct brcmf_sdio *bus, u8 *header,
1187 if ((u16)(~(len ^ checksum))) { 1184 if ((u16)(~(len ^ checksum))) {
1188 brcmf_err("HW header checksum error\n"); 1185 brcmf_err("HW header checksum error\n");
1189 bus->sdcnt.rx_badhdr++; 1186 bus->sdcnt.rx_badhdr++;
1190 brcmf_sdbrcm_rxfail(bus, false, false); 1187 brcmf_sdio_rxfail(bus, false, false);
1191 return -EIO; 1188 return -EIO;
1192 } 1189 }
1193 if (len < SDPCM_HDRLEN) { 1190 if (len < SDPCM_HDRLEN) {
@@ -1219,7 +1216,7 @@ static int brcmf_sdio_hdparse(struct brcmf_sdio *bus, u8 *header,
1219 type != BRCMF_SDIO_FT_SUPER) { 1216 type != BRCMF_SDIO_FT_SUPER) {
1220 brcmf_err("HW header length too long\n"); 1217 brcmf_err("HW header length too long\n");
1221 bus->sdcnt.rx_toolong++; 1218 bus->sdcnt.rx_toolong++;
1222 brcmf_sdbrcm_rxfail(bus, false, false); 1219 brcmf_sdio_rxfail(bus, false, false);
1223 rd->len = 0; 1220 rd->len = 0;
1224 return -EPROTO; 1221 return -EPROTO;
1225 } 1222 }
@@ -1238,7 +1235,7 @@ static int brcmf_sdio_hdparse(struct brcmf_sdio *bus, u8 *header,
1238 if (rd->dat_offset < SDPCM_HDRLEN || rd->dat_offset > rd->len) { 1235 if (rd->dat_offset < SDPCM_HDRLEN || rd->dat_offset > rd->len) {
1239 brcmf_err("seq %d: bad data offset\n", rx_seq); 1236 brcmf_err("seq %d: bad data offset\n", rx_seq);
1240 bus->sdcnt.rx_badhdr++; 1237 bus->sdcnt.rx_badhdr++;
1241 brcmf_sdbrcm_rxfail(bus, false, false); 1238 brcmf_sdio_rxfail(bus, false, false);
1242 rd->len = 0; 1239 rd->len = 0;
1243 return -ENXIO; 1240 return -ENXIO;
1244 } 1241 }
@@ -1311,7 +1308,7 @@ static void brcmf_sdio_hdpack(struct brcmf_sdio *bus, u8 *header,
1311 trace_brcmf_sdpcm_hdr(SDPCM_TX + !!(bus->txglom), header); 1308 trace_brcmf_sdpcm_hdr(SDPCM_TX + !!(bus->txglom), header);
1312} 1309}
1313 1310
1314static u8 brcmf_sdbrcm_rxglom(struct brcmf_sdio *bus, u8 rxseq) 1311static u8 brcmf_sdio_rxglom(struct brcmf_sdio *bus, u8 rxseq)
1315{ 1312{
1316 u16 dlen, totlen; 1313 u16 dlen, totlen;
1317 u8 *dptr, num = 0; 1314 u8 *dptr, num = 0;
@@ -1391,7 +1388,7 @@ static u8 brcmf_sdbrcm_rxglom(struct brcmf_sdio *bus, u8 rxseq)
1391 } 1388 }
1392 pfirst = pnext = NULL; 1389 pfirst = pnext = NULL;
1393 } else { 1390 } else {
1394 brcmf_sdbrcm_free_glom(bus); 1391 brcmf_sdio_free_glom(bus);
1395 num = 0; 1392 num = 0;
1396 } 1393 }
1397 1394
@@ -1414,16 +1411,15 @@ static u8 brcmf_sdbrcm_rxglom(struct brcmf_sdio *bus, u8 rxseq)
1414 } 1411 }
1415 1412
1416 pfirst = skb_peek(&bus->glom); 1413 pfirst = skb_peek(&bus->glom);
1417 dlen = (u16) brcmf_sdbrcm_glom_len(bus); 1414 dlen = (u16) brcmf_sdio_glom_len(bus);
1418 1415
1419 /* Do an SDIO read for the superframe. Configurable iovar to 1416 /* Do an SDIO read for the superframe. Configurable iovar to
1420 * read directly into the chained packet, or allocate a large 1417 * read directly into the chained packet, or allocate a large
1421 * packet and and copy into the chain. 1418 * packet and and copy into the chain.
1422 */ 1419 */
1423 sdio_claim_host(bus->sdiodev->func[1]); 1420 sdio_claim_host(bus->sdiodev->func[1]);
1424 errcode = brcmf_sdcard_recv_chain(bus->sdiodev, 1421 errcode = brcmf_sdiod_recv_chain(bus->sdiodev,
1425 bus->sdiodev->sbwad, 1422 &bus->glom, dlen);
1426 SDIO_FUNC_2, F2SYNC, &bus->glom, dlen);
1427 sdio_release_host(bus->sdiodev->func[1]); 1423 sdio_release_host(bus->sdiodev->func[1]);
1428 bus->sdcnt.f2rxdata++; 1424 bus->sdcnt.f2rxdata++;
1429 1425
@@ -1434,12 +1430,12 @@ static u8 brcmf_sdbrcm_rxglom(struct brcmf_sdio *bus, u8 rxseq)
1434 1430
1435 sdio_claim_host(bus->sdiodev->func[1]); 1431 sdio_claim_host(bus->sdiodev->func[1]);
1436 if (bus->glomerr++ < 3) { 1432 if (bus->glomerr++ < 3) {
1437 brcmf_sdbrcm_rxfail(bus, true, true); 1433 brcmf_sdio_rxfail(bus, true, true);
1438 } else { 1434 } else {
1439 bus->glomerr = 0; 1435 bus->glomerr = 0;
1440 brcmf_sdbrcm_rxfail(bus, true, false); 1436 brcmf_sdio_rxfail(bus, true, false);
1441 bus->sdcnt.rxglomfail++; 1437 bus->sdcnt.rxglomfail++;
1442 brcmf_sdbrcm_free_glom(bus); 1438 brcmf_sdio_free_glom(bus);
1443 } 1439 }
1444 sdio_release_host(bus->sdiodev->func[1]); 1440 sdio_release_host(bus->sdiodev->func[1]);
1445 return 0; 1441 return 0;
@@ -1487,12 +1483,12 @@ static u8 brcmf_sdbrcm_rxglom(struct brcmf_sdio *bus, u8 rxseq)
1487 if (bus->glomerr++ < 3) { 1483 if (bus->glomerr++ < 3) {
1488 /* Restore superframe header space */ 1484 /* Restore superframe header space */
1489 skb_push(pfirst, sfdoff); 1485 skb_push(pfirst, sfdoff);
1490 brcmf_sdbrcm_rxfail(bus, true, true); 1486 brcmf_sdio_rxfail(bus, true, true);
1491 } else { 1487 } else {
1492 bus->glomerr = 0; 1488 bus->glomerr = 0;
1493 brcmf_sdbrcm_rxfail(bus, true, false); 1489 brcmf_sdio_rxfail(bus, true, false);
1494 bus->sdcnt.rxglomfail++; 1490 bus->sdcnt.rxglomfail++;
1495 brcmf_sdbrcm_free_glom(bus); 1491 brcmf_sdio_free_glom(bus);
1496 } 1492 }
1497 sdio_release_host(bus->sdiodev->func[1]); 1493 sdio_release_host(bus->sdiodev->func[1]);
1498 bus->cur_read.len = 0; 1494 bus->cur_read.len = 0;
@@ -1536,8 +1532,8 @@ static u8 brcmf_sdbrcm_rxglom(struct brcmf_sdio *bus, u8 rxseq)
1536 return num; 1532 return num;
1537} 1533}
1538 1534
1539static int brcmf_sdbrcm_dcmd_resp_wait(struct brcmf_sdio *bus, uint *condition, 1535static int brcmf_sdio_dcmd_resp_wait(struct brcmf_sdio *bus, uint *condition,
1540 bool *pending) 1536 bool *pending)
1541{ 1537{
1542 DECLARE_WAITQUEUE(wait, current); 1538 DECLARE_WAITQUEUE(wait, current);
1543 int timeout = msecs_to_jiffies(DCMD_RESP_TIMEOUT); 1539 int timeout = msecs_to_jiffies(DCMD_RESP_TIMEOUT);
@@ -1558,7 +1554,7 @@ static int brcmf_sdbrcm_dcmd_resp_wait(struct brcmf_sdio *bus, uint *condition,
1558 return timeout; 1554 return timeout;
1559} 1555}
1560 1556
1561static int brcmf_sdbrcm_dcmd_resp_wake(struct brcmf_sdio *bus) 1557static int brcmf_sdio_dcmd_resp_wake(struct brcmf_sdio *bus)
1562{ 1558{
1563 if (waitqueue_active(&bus->dcmd_resp_wait)) 1559 if (waitqueue_active(&bus->dcmd_resp_wait))
1564 wake_up_interruptible(&bus->dcmd_resp_wait); 1560 wake_up_interruptible(&bus->dcmd_resp_wait);
@@ -1566,7 +1562,7 @@ static int brcmf_sdbrcm_dcmd_resp_wake(struct brcmf_sdio *bus)
1566 return 0; 1562 return 0;
1567} 1563}
1568static void 1564static void
1569brcmf_sdbrcm_read_control(struct brcmf_sdio *bus, u8 *hdr, uint len, uint doff) 1565brcmf_sdio_read_control(struct brcmf_sdio *bus, u8 *hdr, uint len, uint doff)
1570{ 1566{
1571 uint rdlen, pad; 1567 uint rdlen, pad;
1572 u8 *buf = NULL, *rbuf; 1568 u8 *buf = NULL, *rbuf;
@@ -1604,7 +1600,7 @@ brcmf_sdbrcm_read_control(struct brcmf_sdio *bus, u8 *hdr, uint len, uint doff)
1604 if ((rdlen + BRCMF_FIRSTREAD) > bus->sdiodev->bus_if->maxctl) { 1600 if ((rdlen + BRCMF_FIRSTREAD) > bus->sdiodev->bus_if->maxctl) {
1605 brcmf_err("%d-byte control read exceeds %d-byte buffer\n", 1601 brcmf_err("%d-byte control read exceeds %d-byte buffer\n",
1606 rdlen, bus->sdiodev->bus_if->maxctl); 1602 rdlen, bus->sdiodev->bus_if->maxctl);
1607 brcmf_sdbrcm_rxfail(bus, false, false); 1603 brcmf_sdio_rxfail(bus, false, false);
1608 goto done; 1604 goto done;
1609 } 1605 }
1610 1606
@@ -1612,15 +1608,12 @@ brcmf_sdbrcm_read_control(struct brcmf_sdio *bus, u8 *hdr, uint len, uint doff)
1612 brcmf_err("%d-byte ctl frame (%d-byte ctl data) exceeds %d-byte limit\n", 1608 brcmf_err("%d-byte ctl frame (%d-byte ctl data) exceeds %d-byte limit\n",
1613 len, len - doff, bus->sdiodev->bus_if->maxctl); 1609 len, len - doff, bus->sdiodev->bus_if->maxctl);
1614 bus->sdcnt.rx_toolong++; 1610 bus->sdcnt.rx_toolong++;
1615 brcmf_sdbrcm_rxfail(bus, false, false); 1611 brcmf_sdio_rxfail(bus, false, false);
1616 goto done; 1612 goto done;
1617 } 1613 }
1618 1614
1619 /* Read remain of frame body */ 1615 /* Read remain of frame body */
1620 sdret = brcmf_sdcard_recv_buf(bus->sdiodev, 1616 sdret = brcmf_sdiod_recv_buf(bus->sdiodev, rbuf, rdlen);
1621 bus->sdiodev->sbwad,
1622 SDIO_FUNC_2,
1623 F2SYNC, rbuf, rdlen);
1624 bus->sdcnt.f2rxdata++; 1617 bus->sdcnt.f2rxdata++;
1625 1618
1626 /* Control frame failures need retransmission */ 1619 /* Control frame failures need retransmission */
@@ -1628,7 +1621,7 @@ brcmf_sdbrcm_read_control(struct brcmf_sdio *bus, u8 *hdr, uint len, uint doff)
1628 brcmf_err("read %d control bytes failed: %d\n", 1621 brcmf_err("read %d control bytes failed: %d\n",
1629 rdlen, sdret); 1622 rdlen, sdret);
1630 bus->sdcnt.rxc_errors++; 1623 bus->sdcnt.rxc_errors++;
1631 brcmf_sdbrcm_rxfail(bus, true, true); 1624 brcmf_sdio_rxfail(bus, true, true);
1632 goto done; 1625 goto done;
1633 } else 1626 } else
1634 memcpy(buf + BRCMF_FIRSTREAD, rbuf, rdlen); 1627 memcpy(buf + BRCMF_FIRSTREAD, rbuf, rdlen);
@@ -1653,11 +1646,11 @@ gotpkt:
1653 1646
1654done: 1647done:
1655 /* Awake any waiters */ 1648 /* Awake any waiters */
1656 brcmf_sdbrcm_dcmd_resp_wake(bus); 1649 brcmf_sdio_dcmd_resp_wake(bus);
1657} 1650}
1658 1651
1659/* Pad read to blocksize for efficiency */ 1652/* Pad read to blocksize for efficiency */
1660static void brcmf_pad(struct brcmf_sdio *bus, u16 *pad, u16 *rdlen) 1653static void brcmf_sdio_pad(struct brcmf_sdio *bus, u16 *pad, u16 *rdlen)
1661{ 1654{
1662 if (bus->roundup && bus->blocksize && *rdlen > bus->blocksize) { 1655 if (bus->roundup && bus->blocksize && *rdlen > bus->blocksize) {
1663 *pad = bus->blocksize - (*rdlen % bus->blocksize); 1656 *pad = bus->blocksize - (*rdlen % bus->blocksize);
@@ -1694,7 +1687,7 @@ static uint brcmf_sdio_readframes(struct brcmf_sdio *bus, uint maxframes)
1694 u8 cnt; 1687 u8 cnt;
1695 brcmf_dbg(GLOM, "calling rxglom: glomd %p, glom %p\n", 1688 brcmf_dbg(GLOM, "calling rxglom: glomd %p, glom %p\n",
1696 bus->glomd, skb_peek(&bus->glom)); 1689 bus->glomd, skb_peek(&bus->glom));
1697 cnt = brcmf_sdbrcm_rxglom(bus, rd->seq_num); 1690 cnt = brcmf_sdio_rxglom(bus, rd->seq_num);
1698 brcmf_dbg(GLOM, "rxglom returned %d\n", cnt); 1691 brcmf_dbg(GLOM, "rxglom returned %d\n", cnt);
1699 rd->seq_num += cnt - 1; 1692 rd->seq_num += cnt - 1;
1700 rxleft = (rxleft > cnt) ? (rxleft - cnt) : 1; 1693 rxleft = (rxleft > cnt) ? (rxleft - cnt) : 1;
@@ -1705,17 +1698,14 @@ static uint brcmf_sdio_readframes(struct brcmf_sdio *bus, uint maxframes)
1705 /* read header first for unknow frame length */ 1698 /* read header first for unknow frame length */
1706 sdio_claim_host(bus->sdiodev->func[1]); 1699 sdio_claim_host(bus->sdiodev->func[1]);
1707 if (!rd->len) { 1700 if (!rd->len) {
1708 ret = brcmf_sdcard_recv_buf(bus->sdiodev, 1701 ret = brcmf_sdiod_recv_buf(bus->sdiodev,
1709 bus->sdiodev->sbwad, 1702 bus->rxhdr, BRCMF_FIRSTREAD);
1710 SDIO_FUNC_2, F2SYNC,
1711 bus->rxhdr,
1712 BRCMF_FIRSTREAD);
1713 bus->sdcnt.f2rxhdrs++; 1703 bus->sdcnt.f2rxhdrs++;
1714 if (ret < 0) { 1704 if (ret < 0) {
1715 brcmf_err("RXHEADER FAILED: %d\n", 1705 brcmf_err("RXHEADER FAILED: %d\n",
1716 ret); 1706 ret);
1717 bus->sdcnt.rx_hdrfail++; 1707 bus->sdcnt.rx_hdrfail++;
1718 brcmf_sdbrcm_rxfail(bus, true, true); 1708 brcmf_sdio_rxfail(bus, true, true);
1719 sdio_release_host(bus->sdiodev->func[1]); 1709 sdio_release_host(bus->sdiodev->func[1]);
1720 continue; 1710 continue;
1721 } 1711 }
@@ -1734,9 +1724,9 @@ static uint brcmf_sdio_readframes(struct brcmf_sdio *bus, uint maxframes)
1734 } 1724 }
1735 1725
1736 if (rd->channel == SDPCM_CONTROL_CHANNEL) { 1726 if (rd->channel == SDPCM_CONTROL_CHANNEL) {
1737 brcmf_sdbrcm_read_control(bus, bus->rxhdr, 1727 brcmf_sdio_read_control(bus, bus->rxhdr,
1738 rd->len, 1728 rd->len,
1739 rd->dat_offset); 1729 rd->dat_offset);
1740 /* prepare the descriptor for the next read */ 1730 /* prepare the descriptor for the next read */
1741 rd->len = rd->len_nxtfrm << 4; 1731 rd->len = rd->len_nxtfrm << 4;
1742 rd->len_nxtfrm = 0; 1732 rd->len_nxtfrm = 0;
@@ -1750,14 +1740,14 @@ static uint brcmf_sdio_readframes(struct brcmf_sdio *bus, uint maxframes)
1750 head_read = BRCMF_FIRSTREAD; 1740 head_read = BRCMF_FIRSTREAD;
1751 } 1741 }
1752 1742
1753 brcmf_pad(bus, &pad, &rd->len_left); 1743 brcmf_sdio_pad(bus, &pad, &rd->len_left);
1754 1744
1755 pkt = brcmu_pkt_buf_get_skb(rd->len_left + head_read + 1745 pkt = brcmu_pkt_buf_get_skb(rd->len_left + head_read +
1756 bus->head_align); 1746 bus->head_align);
1757 if (!pkt) { 1747 if (!pkt) {
1758 /* Give up on data, request rtx of events */ 1748 /* Give up on data, request rtx of events */
1759 brcmf_err("brcmu_pkt_buf_get_skb failed\n"); 1749 brcmf_err("brcmu_pkt_buf_get_skb failed\n");
1760 brcmf_sdbrcm_rxfail(bus, false, 1750 brcmf_sdio_rxfail(bus, false,
1761 RETRYCHAN(rd->channel)); 1751 RETRYCHAN(rd->channel));
1762 sdio_release_host(bus->sdiodev->func[1]); 1752 sdio_release_host(bus->sdiodev->func[1]);
1763 continue; 1753 continue;
@@ -1765,8 +1755,7 @@ static uint brcmf_sdio_readframes(struct brcmf_sdio *bus, uint maxframes)
1765 skb_pull(pkt, head_read); 1755 skb_pull(pkt, head_read);
1766 pkt_align(pkt, rd->len_left, bus->head_align); 1756 pkt_align(pkt, rd->len_left, bus->head_align);
1767 1757
1768 ret = brcmf_sdcard_recv_pkt(bus->sdiodev, bus->sdiodev->sbwad, 1758 ret = brcmf_sdiod_recv_pkt(bus->sdiodev, pkt);
1769 SDIO_FUNC_2, F2SYNC, pkt);
1770 bus->sdcnt.f2rxdata++; 1759 bus->sdcnt.f2rxdata++;
1771 sdio_release_host(bus->sdiodev->func[1]); 1760 sdio_release_host(bus->sdiodev->func[1]);
1772 1761
@@ -1775,7 +1764,7 @@ static uint brcmf_sdio_readframes(struct brcmf_sdio *bus, uint maxframes)
1775 rd->len, rd->channel, ret); 1764 rd->len, rd->channel, ret);
1776 brcmu_pkt_buf_free_skb(pkt); 1765 brcmu_pkt_buf_free_skb(pkt);
1777 sdio_claim_host(bus->sdiodev->func[1]); 1766 sdio_claim_host(bus->sdiodev->func[1]);
1778 brcmf_sdbrcm_rxfail(bus, true, 1767 brcmf_sdio_rxfail(bus, true,
1779 RETRYCHAN(rd->channel)); 1768 RETRYCHAN(rd->channel));
1780 sdio_release_host(bus->sdiodev->func[1]); 1769 sdio_release_host(bus->sdiodev->func[1]);
1781 continue; 1770 continue;
@@ -1800,7 +1789,7 @@ static uint brcmf_sdio_readframes(struct brcmf_sdio *bus, uint maxframes)
1800 rd->len, 1789 rd->len,
1801 roundup(rd_new.len, 16) >> 4); 1790 roundup(rd_new.len, 16) >> 4);
1802 rd->len = 0; 1791 rd->len = 0;
1803 brcmf_sdbrcm_rxfail(bus, true, true); 1792 brcmf_sdio_rxfail(bus, true, true);
1804 sdio_release_host(bus->sdiodev->func[1]); 1793 sdio_release_host(bus->sdiodev->func[1]);
1805 brcmu_pkt_buf_free_skb(pkt); 1794 brcmu_pkt_buf_free_skb(pkt);
1806 continue; 1795 continue;
@@ -1822,7 +1811,7 @@ static uint brcmf_sdio_readframes(struct brcmf_sdio *bus, uint maxframes)
1822 /* Force retry w/normal header read */ 1811 /* Force retry w/normal header read */
1823 rd->len = 0; 1812 rd->len = 0;
1824 sdio_claim_host(bus->sdiodev->func[1]); 1813 sdio_claim_host(bus->sdiodev->func[1]);
1825 brcmf_sdbrcm_rxfail(bus, false, true); 1814 brcmf_sdio_rxfail(bus, false, true);
1826 sdio_release_host(bus->sdiodev->func[1]); 1815 sdio_release_host(bus->sdiodev->func[1]);
1827 brcmu_pkt_buf_free_skb(pkt); 1816 brcmu_pkt_buf_free_skb(pkt);
1828 continue; 1817 continue;
@@ -1847,7 +1836,7 @@ static uint brcmf_sdio_readframes(struct brcmf_sdio *bus, uint maxframes)
1847 brcmf_err("%s: glom superframe w/o " 1836 brcmf_err("%s: glom superframe w/o "
1848 "descriptor!\n", __func__); 1837 "descriptor!\n", __func__);
1849 sdio_claim_host(bus->sdiodev->func[1]); 1838 sdio_claim_host(bus->sdiodev->func[1]);
1850 brcmf_sdbrcm_rxfail(bus, false, false); 1839 brcmf_sdio_rxfail(bus, false, false);
1851 sdio_release_host(bus->sdiodev->func[1]); 1840 sdio_release_host(bus->sdiodev->func[1]);
1852 } 1841 }
1853 /* prepare the descriptor for the next read */ 1842 /* prepare the descriptor for the next read */
@@ -1891,7 +1880,7 @@ static uint brcmf_sdio_readframes(struct brcmf_sdio *bus, uint maxframes)
1891} 1880}
1892 1881
1893static void 1882static void
1894brcmf_sdbrcm_wait_event_wakeup(struct brcmf_sdio *bus) 1883brcmf_sdio_wait_event_wakeup(struct brcmf_sdio *bus)
1895{ 1884{
1896 if (waitqueue_active(&bus->ctrl_wait)) 1885 if (waitqueue_active(&bus->ctrl_wait))
1897 wake_up_interruptible(&bus->ctrl_wait); 1886 wake_up_interruptible(&bus->ctrl_wait);
@@ -2107,8 +2096,8 @@ brcmf_sdio_txpkt_postp(struct brcmf_sdio *bus, struct sk_buff_head *pktq)
2107 2096
2108/* Writes a HW/SW header into the packet and sends it. */ 2097/* Writes a HW/SW header into the packet and sends it. */
2109/* Assumes: (a) header space already there, (b) caller holds lock */ 2098/* Assumes: (a) header space already there, (b) caller holds lock */
2110static int brcmf_sdbrcm_txpkt(struct brcmf_sdio *bus, struct sk_buff_head *pktq, 2099static int brcmf_sdio_txpkt(struct brcmf_sdio *bus, struct sk_buff_head *pktq,
2111 uint chan) 2100 uint chan)
2112{ 2101{
2113 int ret; 2102 int ret;
2114 int i; 2103 int i;
@@ -2121,8 +2110,7 @@ static int brcmf_sdbrcm_txpkt(struct brcmf_sdio *bus, struct sk_buff_head *pktq,
2121 goto done; 2110 goto done;
2122 2111
2123 sdio_claim_host(bus->sdiodev->func[1]); 2112 sdio_claim_host(bus->sdiodev->func[1]);
2124 ret = brcmf_sdcard_send_pkt(bus->sdiodev, bus->sdiodev->sbwad, 2113 ret = brcmf_sdiod_send_pkt(bus->sdiodev, pktq);
2125 SDIO_FUNC_2, F2SYNC, pktq);
2126 bus->sdcnt.f2txdata++; 2114 bus->sdcnt.f2txdata++;
2127 2115
2128 if (ret < 0) { 2116 if (ret < 0) {
@@ -2131,17 +2119,17 @@ static int brcmf_sdbrcm_txpkt(struct brcmf_sdio *bus, struct sk_buff_head *pktq,
2131 ret); 2119 ret);
2132 bus->sdcnt.tx_sderrs++; 2120 bus->sdcnt.tx_sderrs++;
2133 2121
2134 brcmf_sdcard_abort(bus->sdiodev, SDIO_FUNC_2); 2122 brcmf_sdiod_abort(bus->sdiodev, SDIO_FUNC_2);
2135 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_FRAMECTRL, 2123 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_FRAMECTRL,
2136 SFC_WF_TERM, NULL); 2124 SFC_WF_TERM, NULL);
2137 bus->sdcnt.f1regdata++; 2125 bus->sdcnt.f1regdata++;
2138 2126
2139 for (i = 0; i < 3; i++) { 2127 for (i = 0; i < 3; i++) {
2140 u8 hi, lo; 2128 u8 hi, lo;
2141 hi = brcmf_sdio_regrb(bus->sdiodev, 2129 hi = brcmf_sdiod_regrb(bus->sdiodev,
2142 SBSDIO_FUNC1_WFRAMEBCHI, NULL); 2130 SBSDIO_FUNC1_WFRAMEBCHI, NULL);
2143 lo = brcmf_sdio_regrb(bus->sdiodev, 2131 lo = brcmf_sdiod_regrb(bus->sdiodev,
2144 SBSDIO_FUNC1_WFRAMEBCLO, NULL); 2132 SBSDIO_FUNC1_WFRAMEBCLO, NULL);
2145 bus->sdcnt.f1regdata += 2; 2133 bus->sdcnt.f1regdata += 2;
2146 if ((hi == 0) && (lo == 0)) 2134 if ((hi == 0) && (lo == 0))
2147 break; 2135 break;
@@ -2160,7 +2148,7 @@ done:
2160 return ret; 2148 return ret;
2161} 2149}
2162 2150
2163static uint brcmf_sdbrcm_sendfromq(struct brcmf_sdio *bus, uint maxframes) 2151static uint brcmf_sdio_sendfromq(struct brcmf_sdio *bus, uint maxframes)
2164{ 2152{
2165 struct sk_buff *pkt; 2153 struct sk_buff *pkt;
2166 struct sk_buff_head pktq; 2154 struct sk_buff_head pktq;
@@ -2194,7 +2182,7 @@ static uint brcmf_sdbrcm_sendfromq(struct brcmf_sdio *bus, uint maxframes)
2194 if (i == 0) 2182 if (i == 0)
2195 break; 2183 break;
2196 2184
2197 ret = brcmf_sdbrcm_txpkt(bus, &pktq, SDPCM_DATA_CHANNEL); 2185 ret = brcmf_sdio_txpkt(bus, &pktq, SDPCM_DATA_CHANNEL);
2198 cnt += i; 2186 cnt += i;
2199 2187
2200 /* In poll mode, need to check for other events */ 2188 /* In poll mode, need to check for other events */
@@ -2223,7 +2211,7 @@ static uint brcmf_sdbrcm_sendfromq(struct brcmf_sdio *bus, uint maxframes)
2223 return cnt; 2211 return cnt;
2224} 2212}
2225 2213
2226static void brcmf_sdbrcm_bus_stop(struct device *dev) 2214static void brcmf_sdio_bus_stop(struct device *dev)
2227{ 2215{
2228 u32 local_hostintmask; 2216 u32 local_hostintmask;
2229 u8 saveclk; 2217 u8 saveclk;
@@ -2243,7 +2231,7 @@ static void brcmf_sdbrcm_bus_stop(struct device *dev)
2243 sdio_claim_host(bus->sdiodev->func[1]); 2231 sdio_claim_host(bus->sdiodev->func[1]);
2244 2232
2245 /* Enable clock for device interrupts */ 2233 /* Enable clock for device interrupts */
2246 brcmf_sdbrcm_bus_sleep(bus, false, false); 2234 brcmf_sdio_bus_sleep(bus, false, false);
2247 2235
2248 /* Disable and clear interrupts at the chip level also */ 2236 /* Disable and clear interrupts at the chip level also */
2249 w_sdreg32(bus, 0, offsetof(struct sdpcmd_regs, hostintmask)); 2237 w_sdreg32(bus, 0, offsetof(struct sdpcmd_regs, hostintmask));
@@ -2254,26 +2242,25 @@ static void brcmf_sdbrcm_bus_stop(struct device *dev)
2254 bus->sdiodev->bus_if->state = BRCMF_BUS_DOWN; 2242 bus->sdiodev->bus_if->state = BRCMF_BUS_DOWN;
2255 2243
2256 /* Force clocks on backplane to be sure F2 interrupt propagates */ 2244 /* Force clocks on backplane to be sure F2 interrupt propagates */
2257 saveclk = brcmf_sdio_regrb(bus->sdiodev, 2245 saveclk = brcmf_sdiod_regrb(bus->sdiodev,
2258 SBSDIO_FUNC1_CHIPCLKCSR, &err); 2246 SBSDIO_FUNC1_CHIPCLKCSR, &err);
2259 if (!err) { 2247 if (!err) {
2260 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, 2248 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR,
2261 (saveclk | SBSDIO_FORCE_HT), &err); 2249 (saveclk | SBSDIO_FORCE_HT), &err);
2262 } 2250 }
2263 if (err) 2251 if (err)
2264 brcmf_err("Failed to force clock for F2: err %d\n", err); 2252 brcmf_err("Failed to force clock for F2: err %d\n", err);
2265 2253
2266 /* Turn off the bus (F2), free any pending packets */ 2254 /* Turn off the bus (F2), free any pending packets */
2267 brcmf_dbg(INTR, "disable SDIO interrupts\n"); 2255 brcmf_dbg(INTR, "disable SDIO interrupts\n");
2268 brcmf_sdio_regwb(bus->sdiodev, SDIO_CCCR_IOEx, SDIO_FUNC_ENABLE_1, 2256 sdio_disable_func(bus->sdiodev->func[SDIO_FUNC_2]);
2269 NULL);
2270 2257
2271 /* Clear any pending interrupts now that F2 is disabled */ 2258 /* Clear any pending interrupts now that F2 is disabled */
2272 w_sdreg32(bus, local_hostintmask, 2259 w_sdreg32(bus, local_hostintmask,
2273 offsetof(struct sdpcmd_regs, intstatus)); 2260 offsetof(struct sdpcmd_regs, intstatus));
2274 2261
2275 /* Turn off the backplane clock (only) */ 2262 /* Turn off the backplane clock (only) */
2276 brcmf_sdbrcm_clkctl(bus, CLK_SDONLY, false); 2263 brcmf_sdio_clkctl(bus, CLK_SDONLY, false);
2277 sdio_release_host(bus->sdiodev->func[1]); 2264 sdio_release_host(bus->sdiodev->func[1]);
2278 2265
2279 /* Clear the data packet queues */ 2266 /* Clear the data packet queues */
@@ -2282,20 +2269,20 @@ static void brcmf_sdbrcm_bus_stop(struct device *dev)
2282 /* Clear any held glomming stuff */ 2269 /* Clear any held glomming stuff */
2283 if (bus->glomd) 2270 if (bus->glomd)
2284 brcmu_pkt_buf_free_skb(bus->glomd); 2271 brcmu_pkt_buf_free_skb(bus->glomd);
2285 brcmf_sdbrcm_free_glom(bus); 2272 brcmf_sdio_free_glom(bus);
2286 2273
2287 /* Clear rx control and wake any waiters */ 2274 /* Clear rx control and wake any waiters */
2288 spin_lock_bh(&bus->rxctl_lock); 2275 spin_lock_bh(&bus->rxctl_lock);
2289 bus->rxlen = 0; 2276 bus->rxlen = 0;
2290 spin_unlock_bh(&bus->rxctl_lock); 2277 spin_unlock_bh(&bus->rxctl_lock);
2291 brcmf_sdbrcm_dcmd_resp_wake(bus); 2278 brcmf_sdio_dcmd_resp_wake(bus);
2292 2279
2293 /* Reset some F2 state stuff */ 2280 /* Reset some F2 state stuff */
2294 bus->rxskip = false; 2281 bus->rxskip = false;
2295 bus->tx_seq = bus->rx_seq = 0; 2282 bus->tx_seq = bus->rx_seq = 0;
2296} 2283}
2297 2284
2298static inline void brcmf_sdbrcm_clrintr(struct brcmf_sdio *bus) 2285static inline void brcmf_sdio_clrintr(struct brcmf_sdio *bus)
2299{ 2286{
2300 unsigned long flags; 2287 unsigned long flags;
2301 2288
@@ -2320,7 +2307,7 @@ static int brcmf_sdio_intr_rstatus(struct brcmf_sdio *bus)
2320 addr = bus->ci->c_inf[idx].base + 2307 addr = bus->ci->c_inf[idx].base +
2321 offsetof(struct sdpcmd_regs, intstatus); 2308 offsetof(struct sdpcmd_regs, intstatus);
2322 2309
2323 ret = brcmf_sdio_regrw_helper(bus->sdiodev, addr, &val, false); 2310 val = brcmf_sdiod_regrl(bus->sdiodev, addr, &ret);
2324 bus->sdcnt.f1regdata++; 2311 bus->sdcnt.f1regdata++;
2325 if (ret != 0) 2312 if (ret != 0)
2326 val = 0; 2313 val = 0;
@@ -2330,7 +2317,7 @@ static int brcmf_sdio_intr_rstatus(struct brcmf_sdio *bus)
2330 2317
2331 /* Clear interrupts */ 2318 /* Clear interrupts */
2332 if (val) { 2319 if (val) {
2333 ret = brcmf_sdio_regrw_helper(bus->sdiodev, addr, &val, true); 2320 brcmf_sdiod_regwl(bus->sdiodev, addr, val, &ret);
2334 bus->sdcnt.f1regdata++; 2321 bus->sdcnt.f1regdata++;
2335 } 2322 }
2336 2323
@@ -2344,7 +2331,7 @@ static int brcmf_sdio_intr_rstatus(struct brcmf_sdio *bus)
2344 return ret; 2331 return ret;
2345} 2332}
2346 2333
2347static void brcmf_sdbrcm_dpc(struct brcmf_sdio *bus) 2334static void brcmf_sdio_dpc(struct brcmf_sdio *bus)
2348{ 2335{
2349 u32 newstatus = 0; 2336 u32 newstatus = 0;
2350 unsigned long intstatus; 2337 unsigned long intstatus;
@@ -2363,8 +2350,8 @@ static void brcmf_sdbrcm_dpc(struct brcmf_sdio *bus)
2363 2350
2364#ifdef DEBUG 2351#ifdef DEBUG
2365 /* Check for inconsistent device control */ 2352 /* Check for inconsistent device control */
2366 devctl = brcmf_sdio_regrb(bus->sdiodev, 2353 devctl = brcmf_sdiod_regrb(bus->sdiodev,
2367 SBSDIO_DEVICE_CTL, &err); 2354 SBSDIO_DEVICE_CTL, &err);
2368 if (err) { 2355 if (err) {
2369 brcmf_err("error reading DEVCTL: %d\n", err); 2356 brcmf_err("error reading DEVCTL: %d\n", err);
2370 bus->sdiodev->bus_if->state = BRCMF_BUS_DOWN; 2357 bus->sdiodev->bus_if->state = BRCMF_BUS_DOWN;
@@ -2372,8 +2359,8 @@ static void brcmf_sdbrcm_dpc(struct brcmf_sdio *bus)
2372#endif /* DEBUG */ 2359#endif /* DEBUG */
2373 2360
2374 /* Read CSR, if clock on switch to AVAIL, else ignore */ 2361 /* Read CSR, if clock on switch to AVAIL, else ignore */
2375 clkctl = brcmf_sdio_regrb(bus->sdiodev, 2362 clkctl = brcmf_sdiod_regrb(bus->sdiodev,
2376 SBSDIO_FUNC1_CHIPCLKCSR, &err); 2363 SBSDIO_FUNC1_CHIPCLKCSR, &err);
2377 if (err) { 2364 if (err) {
2378 brcmf_err("error reading CSR: %d\n", 2365 brcmf_err("error reading CSR: %d\n",
2379 err); 2366 err);
@@ -2384,16 +2371,16 @@ static void brcmf_sdbrcm_dpc(struct brcmf_sdio *bus)
2384 devctl, clkctl); 2371 devctl, clkctl);
2385 2372
2386 if (SBSDIO_HTAV(clkctl)) { 2373 if (SBSDIO_HTAV(clkctl)) {
2387 devctl = brcmf_sdio_regrb(bus->sdiodev, 2374 devctl = brcmf_sdiod_regrb(bus->sdiodev,
2388 SBSDIO_DEVICE_CTL, &err); 2375 SBSDIO_DEVICE_CTL, &err);
2389 if (err) { 2376 if (err) {
2390 brcmf_err("error reading DEVCTL: %d\n", 2377 brcmf_err("error reading DEVCTL: %d\n",
2391 err); 2378 err);
2392 bus->sdiodev->bus_if->state = BRCMF_BUS_DOWN; 2379 bus->sdiodev->bus_if->state = BRCMF_BUS_DOWN;
2393 } 2380 }
2394 devctl &= ~SBSDIO_DEVCTL_CA_INT_ONLY; 2381 devctl &= ~SBSDIO_DEVCTL_CA_INT_ONLY;
2395 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_DEVICE_CTL, 2382 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_DEVICE_CTL,
2396 devctl, &err); 2383 devctl, &err);
2397 if (err) { 2384 if (err) {
2398 brcmf_err("error writing DEVCTL: %d\n", 2385 brcmf_err("error writing DEVCTL: %d\n",
2399 err); 2386 err);
@@ -2404,7 +2391,7 @@ static void brcmf_sdbrcm_dpc(struct brcmf_sdio *bus)
2404 } 2391 }
2405 2392
2406 /* Make sure backplane clock is on */ 2393 /* Make sure backplane clock is on */
2407 brcmf_sdbrcm_bus_sleep(bus, false, true); 2394 brcmf_sdio_bus_sleep(bus, false, true);
2408 2395
2409 /* Pending interrupt indicates new device status */ 2396 /* Pending interrupt indicates new device status */
2410 if (atomic_read(&bus->ipend) > 0) { 2397 if (atomic_read(&bus->ipend) > 0) {
@@ -2435,7 +2422,7 @@ static void brcmf_sdbrcm_dpc(struct brcmf_sdio *bus)
2435 /* Handle host mailbox indication */ 2422 /* Handle host mailbox indication */
2436 if (intstatus & I_HMB_HOST_INT) { 2423 if (intstatus & I_HMB_HOST_INT) {
2437 intstatus &= ~I_HMB_HOST_INT; 2424 intstatus &= ~I_HMB_HOST_INT;
2438 intstatus |= brcmf_sdbrcm_hostmail(bus); 2425 intstatus |= brcmf_sdio_hostmail(bus);
2439 } 2426 }
2440 2427
2441 sdio_release_host(bus->sdiodev->func[1]); 2428 sdio_release_host(bus->sdiodev->func[1]);
@@ -2480,16 +2467,15 @@ static void brcmf_sdbrcm_dpc(struct brcmf_sdio *bus)
2480 set_bit(n, (unsigned long *)&bus->intstatus.counter); 2467 set_bit(n, (unsigned long *)&bus->intstatus.counter);
2481 } 2468 }
2482 2469
2483 brcmf_sdbrcm_clrintr(bus); 2470 brcmf_sdio_clrintr(bus);
2484 2471
2485 if (data_ok(bus) && bus->ctrl_frame_stat && 2472 if (data_ok(bus) && bus->ctrl_frame_stat &&
2486 (bus->clkstate == CLK_AVAIL)) { 2473 (bus->clkstate == CLK_AVAIL)) {
2487 int i; 2474 int i;
2488 2475
2489 sdio_claim_host(bus->sdiodev->func[1]); 2476 sdio_claim_host(bus->sdiodev->func[1]);
2490 err = brcmf_sdcard_send_buf(bus->sdiodev, bus->sdiodev->sbwad, 2477 err = brcmf_sdiod_send_buf(bus->sdiodev, bus->ctrl_frame_buf,
2491 SDIO_FUNC_2, F2SYNC, bus->ctrl_frame_buf, 2478 (u32)bus->ctrl_frame_len);
2492 (u32) bus->ctrl_frame_len);
2493 2479
2494 if (err < 0) { 2480 if (err < 0) {
2495 /* On failure, abort the command and 2481 /* On failure, abort the command and
@@ -2498,20 +2484,20 @@ static void brcmf_sdbrcm_dpc(struct brcmf_sdio *bus)
2498 err); 2484 err);
2499 bus->sdcnt.tx_sderrs++; 2485 bus->sdcnt.tx_sderrs++;
2500 2486
2501 brcmf_sdcard_abort(bus->sdiodev, SDIO_FUNC_2); 2487 brcmf_sdiod_abort(bus->sdiodev, SDIO_FUNC_2);
2502 2488
2503 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_FRAMECTRL, 2489 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_FRAMECTRL,
2504 SFC_WF_TERM, &err); 2490 SFC_WF_TERM, &err);
2505 bus->sdcnt.f1regdata++; 2491 bus->sdcnt.f1regdata++;
2506 2492
2507 for (i = 0; i < 3; i++) { 2493 for (i = 0; i < 3; i++) {
2508 u8 hi, lo; 2494 u8 hi, lo;
2509 hi = brcmf_sdio_regrb(bus->sdiodev, 2495 hi = brcmf_sdiod_regrb(bus->sdiodev,
2510 SBSDIO_FUNC1_WFRAMEBCHI, 2496 SBSDIO_FUNC1_WFRAMEBCHI,
2511 &err); 2497 &err);
2512 lo = brcmf_sdio_regrb(bus->sdiodev, 2498 lo = brcmf_sdiod_regrb(bus->sdiodev,
2513 SBSDIO_FUNC1_WFRAMEBCLO, 2499 SBSDIO_FUNC1_WFRAMEBCLO,
2514 &err); 2500 &err);
2515 bus->sdcnt.f1regdata += 2; 2501 bus->sdcnt.f1regdata += 2;
2516 if ((hi == 0) && (lo == 0)) 2502 if ((hi == 0) && (lo == 0))
2517 break; 2503 break;
@@ -2522,7 +2508,7 @@ static void brcmf_sdbrcm_dpc(struct brcmf_sdio *bus)
2522 } 2508 }
2523 sdio_release_host(bus->sdiodev->func[1]); 2509 sdio_release_host(bus->sdiodev->func[1]);
2524 bus->ctrl_frame_stat = false; 2510 bus->ctrl_frame_stat = false;
2525 brcmf_sdbrcm_wait_event_wakeup(bus); 2511 brcmf_sdio_wait_event_wakeup(bus);
2526 } 2512 }
2527 /* Send queued frames (limit 1 if rx may still be pending) */ 2513 /* Send queued frames (limit 1 if rx may still be pending) */
2528 else if ((bus->clkstate == CLK_AVAIL) && !atomic_read(&bus->fcstate) && 2514 else if ((bus->clkstate == CLK_AVAIL) && !atomic_read(&bus->fcstate) &&
@@ -2530,7 +2516,7 @@ static void brcmf_sdbrcm_dpc(struct brcmf_sdio *bus)
2530 && data_ok(bus)) { 2516 && data_ok(bus)) {
2531 framecnt = bus->rxpending ? min(txlimit, bus->txminmax) : 2517 framecnt = bus->rxpending ? min(txlimit, bus->txminmax) :
2532 txlimit; 2518 txlimit;
2533 framecnt = brcmf_sdbrcm_sendfromq(bus, framecnt); 2519 framecnt = brcmf_sdio_sendfromq(bus, framecnt);
2534 txlimit -= framecnt; 2520 txlimit -= framecnt;
2535 } 2521 }
2536 2522
@@ -2552,12 +2538,12 @@ static void brcmf_sdbrcm_dpc(struct brcmf_sdio *bus)
2552 bus->activity = false; 2538 bus->activity = false;
2553 brcmf_dbg(SDIO, "idle state\n"); 2539 brcmf_dbg(SDIO, "idle state\n");
2554 sdio_claim_host(bus->sdiodev->func[1]); 2540 sdio_claim_host(bus->sdiodev->func[1]);
2555 brcmf_sdbrcm_bus_sleep(bus, true, false); 2541 brcmf_sdio_bus_sleep(bus, true, false);
2556 sdio_release_host(bus->sdiodev->func[1]); 2542 sdio_release_host(bus->sdiodev->func[1]);
2557 } 2543 }
2558} 2544}
2559 2545
2560static struct pktq *brcmf_sdbrcm_bus_gettxq(struct device *dev) 2546static struct pktq *brcmf_sdio_bus_gettxq(struct device *dev)
2561{ 2547{
2562 struct brcmf_bus *bus_if = dev_get_drvdata(dev); 2548 struct brcmf_bus *bus_if = dev_get_drvdata(dev);
2563 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio; 2549 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
@@ -2566,7 +2552,7 @@ static struct pktq *brcmf_sdbrcm_bus_gettxq(struct device *dev)
2566 return &bus->txq; 2552 return &bus->txq;
2567} 2553}
2568 2554
2569static int brcmf_sdbrcm_bus_txdata(struct device *dev, struct sk_buff *pkt) 2555static int brcmf_sdio_bus_txdata(struct device *dev, struct sk_buff *pkt)
2570{ 2556{
2571 int ret = -EBADE; 2557 int ret = -EBADE;
2572 uint datalen, prec; 2558 uint datalen, prec;
@@ -2622,7 +2608,7 @@ static int brcmf_sdbrcm_bus_txdata(struct device *dev, struct sk_buff *pkt)
2622#ifdef DEBUG 2608#ifdef DEBUG
2623#define CONSOLE_LINE_MAX 192 2609#define CONSOLE_LINE_MAX 192
2624 2610
2625static int brcmf_sdbrcm_readconsole(struct brcmf_sdio *bus) 2611static int brcmf_sdio_readconsole(struct brcmf_sdio *bus)
2626{ 2612{
2627 struct brcmf_console *c = &bus->console; 2613 struct brcmf_console *c = &bus->console;
2628 u8 line[CONSOLE_LINE_MAX], ch; 2614 u8 line[CONSOLE_LINE_MAX], ch;
@@ -2635,8 +2621,8 @@ static int brcmf_sdbrcm_readconsole(struct brcmf_sdio *bus)
2635 2621
2636 /* Read console log struct */ 2622 /* Read console log struct */
2637 addr = bus->console_addr + offsetof(struct rte_console, log_le); 2623 addr = bus->console_addr + offsetof(struct rte_console, log_le);
2638 rv = brcmf_sdio_ramrw(bus->sdiodev, false, addr, (u8 *)&c->log_le, 2624 rv = brcmf_sdiod_ramrw(bus->sdiodev, false, addr, (u8 *)&c->log_le,
2639 sizeof(c->log_le)); 2625 sizeof(c->log_le));
2640 if (rv < 0) 2626 if (rv < 0)
2641 return rv; 2627 return rv;
2642 2628
@@ -2661,7 +2647,7 @@ static int brcmf_sdbrcm_readconsole(struct brcmf_sdio *bus)
2661 2647
2662 /* Read the console buffer */ 2648 /* Read the console buffer */
2663 addr = le32_to_cpu(c->log_le.buf); 2649 addr = le32_to_cpu(c->log_le.buf);
2664 rv = brcmf_sdio_ramrw(bus->sdiodev, false, addr, c->buf, c->bufsize); 2650 rv = brcmf_sdiod_ramrw(bus->sdiodev, false, addr, c->buf, c->bufsize);
2665 if (rv < 0) 2651 if (rv < 0)
2666 return rv; 2652 return rv;
2667 2653
@@ -2699,14 +2685,13 @@ break2:
2699} 2685}
2700#endif /* DEBUG */ 2686#endif /* DEBUG */
2701 2687
2702static int brcmf_tx_frame(struct brcmf_sdio *bus, u8 *frame, u16 len) 2688static int brcmf_sdio_tx_frame(struct brcmf_sdio *bus, u8 *frame, u16 len)
2703{ 2689{
2704 int i; 2690 int i;
2705 int ret; 2691 int ret;
2706 2692
2707 bus->ctrl_frame_stat = false; 2693 bus->ctrl_frame_stat = false;
2708 ret = brcmf_sdcard_send_buf(bus->sdiodev, bus->sdiodev->sbwad, 2694 ret = brcmf_sdiod_send_buf(bus->sdiodev, frame, len);
2709 SDIO_FUNC_2, F2SYNC, frame, len);
2710 2695
2711 if (ret < 0) { 2696 if (ret < 0) {
2712 /* On failure, abort the command and terminate the frame */ 2697 /* On failure, abort the command and terminate the frame */
@@ -2714,18 +2699,18 @@ static int brcmf_tx_frame(struct brcmf_sdio *bus, u8 *frame, u16 len)
2714 ret); 2699 ret);
2715 bus->sdcnt.tx_sderrs++; 2700 bus->sdcnt.tx_sderrs++;
2716 2701
2717 brcmf_sdcard_abort(bus->sdiodev, SDIO_FUNC_2); 2702 brcmf_sdiod_abort(bus->sdiodev, SDIO_FUNC_2);
2718 2703
2719 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_FRAMECTRL, 2704 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_FRAMECTRL,
2720 SFC_WF_TERM, NULL); 2705 SFC_WF_TERM, NULL);
2721 bus->sdcnt.f1regdata++; 2706 bus->sdcnt.f1regdata++;
2722 2707
2723 for (i = 0; i < 3; i++) { 2708 for (i = 0; i < 3; i++) {
2724 u8 hi, lo; 2709 u8 hi, lo;
2725 hi = brcmf_sdio_regrb(bus->sdiodev, 2710 hi = brcmf_sdiod_regrb(bus->sdiodev,
2726 SBSDIO_FUNC1_WFRAMEBCHI, NULL); 2711 SBSDIO_FUNC1_WFRAMEBCHI, NULL);
2727 lo = brcmf_sdio_regrb(bus->sdiodev, 2712 lo = brcmf_sdiod_regrb(bus->sdiodev,
2728 SBSDIO_FUNC1_WFRAMEBCLO, NULL); 2713 SBSDIO_FUNC1_WFRAMEBCLO, NULL);
2729 bus->sdcnt.f1regdata += 2; 2714 bus->sdcnt.f1regdata += 2;
2730 if (hi == 0 && lo == 0) 2715 if (hi == 0 && lo == 0)
2731 break; 2716 break;
@@ -2739,7 +2724,7 @@ static int brcmf_tx_frame(struct brcmf_sdio *bus, u8 *frame, u16 len)
2739} 2724}
2740 2725
2741static int 2726static int
2742brcmf_sdbrcm_bus_txctl(struct device *dev, unsigned char *msg, uint msglen) 2727brcmf_sdio_bus_txctl(struct device *dev, unsigned char *msg, uint msglen)
2743{ 2728{
2744 u8 *frame; 2729 u8 *frame;
2745 u16 len, pad; 2730 u16 len, pad;
@@ -2783,7 +2768,7 @@ brcmf_sdbrcm_bus_txctl(struct device *dev, unsigned char *msg, uint msglen)
2783 2768
2784 /* Make sure backplane clock is on */ 2769 /* Make sure backplane clock is on */
2785 sdio_claim_host(bus->sdiodev->func[1]); 2770 sdio_claim_host(bus->sdiodev->func[1]);
2786 brcmf_sdbrcm_bus_sleep(bus, false, false); 2771 brcmf_sdio_bus_sleep(bus, false, false);
2787 sdio_release_host(bus->sdiodev->func[1]); 2772 sdio_release_host(bus->sdiodev->func[1]);
2788 2773
2789 hd_info.len = (u16)msglen; 2774 hd_info.len = (u16)msglen;
@@ -2827,7 +2812,7 @@ brcmf_sdbrcm_bus_txctl(struct device *dev, unsigned char *msg, uint msglen)
2827 2812
2828 do { 2813 do {
2829 sdio_claim_host(bus->sdiodev->func[1]); 2814 sdio_claim_host(bus->sdiodev->func[1]);
2830 ret = brcmf_tx_frame(bus, frame, len); 2815 ret = brcmf_sdio_tx_frame(bus, frame, len);
2831 sdio_release_host(bus->sdiodev->func[1]); 2816 sdio_release_host(bus->sdiodev->func[1]);
2832 } while (ret < 0 && retries++ < TXRETRIES); 2817 } while (ret < 0 && retries++ < TXRETRIES);
2833 } 2818 }
@@ -2837,7 +2822,7 @@ brcmf_sdbrcm_bus_txctl(struct device *dev, unsigned char *msg, uint msglen)
2837 bus->activity = false; 2822 bus->activity = false;
2838 sdio_claim_host(bus->sdiodev->func[1]); 2823 sdio_claim_host(bus->sdiodev->func[1]);
2839 brcmf_dbg(INFO, "idle\n"); 2824 brcmf_dbg(INFO, "idle\n");
2840 brcmf_sdbrcm_clkctl(bus, CLK_NONE, true); 2825 brcmf_sdio_clkctl(bus, CLK_NONE, true);
2841 sdio_release_host(bus->sdiodev->func[1]); 2826 sdio_release_host(bus->sdiodev->func[1]);
2842 } 2827 }
2843 2828
@@ -2871,8 +2856,8 @@ static int brcmf_sdio_readshared(struct brcmf_sdio *bus,
2871 * address of sdpcm_shared structure 2856 * address of sdpcm_shared structure
2872 */ 2857 */
2873 sdio_claim_host(bus->sdiodev->func[1]); 2858 sdio_claim_host(bus->sdiodev->func[1]);
2874 brcmf_sdbrcm_bus_sleep(bus, false, false); 2859 brcmf_sdio_bus_sleep(bus, false, false);
2875 rv = brcmf_sdio_ramrw(bus->sdiodev, false, shaddr, (u8 *)&addr_le, 4); 2860 rv = brcmf_sdiod_ramrw(bus->sdiodev, false, shaddr, (u8 *)&addr_le, 4);
2876 sdio_release_host(bus->sdiodev->func[1]); 2861 sdio_release_host(bus->sdiodev->func[1]);
2877 if (rv < 0) 2862 if (rv < 0)
2878 return rv; 2863 return rv;
@@ -2892,8 +2877,8 @@ static int brcmf_sdio_readshared(struct brcmf_sdio *bus,
2892 } 2877 }
2893 2878
2894 /* Read hndrte_shared structure */ 2879 /* Read hndrte_shared structure */
2895 rv = brcmf_sdio_ramrw(bus->sdiodev, false, addr, (u8 *)&sh_le, 2880 rv = brcmf_sdiod_ramrw(bus->sdiodev, false, addr, (u8 *)&sh_le,
2896 sizeof(struct sdpcm_shared_le)); 2881 sizeof(struct sdpcm_shared_le));
2897 if (rv < 0) 2882 if (rv < 0)
2898 return rv; 2883 return rv;
2899 2884
@@ -2929,22 +2914,22 @@ static int brcmf_sdio_dump_console(struct brcmf_sdio *bus,
2929 2914
2930 /* obtain console information from device memory */ 2915 /* obtain console information from device memory */
2931 addr = sh->console_addr + offsetof(struct rte_console, log_le); 2916 addr = sh->console_addr + offsetof(struct rte_console, log_le);
2932 rv = brcmf_sdio_ramrw(bus->sdiodev, false, addr, 2917 rv = brcmf_sdiod_ramrw(bus->sdiodev, false, addr,
2933 (u8 *)&sh_val, sizeof(u32)); 2918 (u8 *)&sh_val, sizeof(u32));
2934 if (rv < 0) 2919 if (rv < 0)
2935 return rv; 2920 return rv;
2936 console_ptr = le32_to_cpu(sh_val); 2921 console_ptr = le32_to_cpu(sh_val);
2937 2922
2938 addr = sh->console_addr + offsetof(struct rte_console, log_le.buf_size); 2923 addr = sh->console_addr + offsetof(struct rte_console, log_le.buf_size);
2939 rv = brcmf_sdio_ramrw(bus->sdiodev, false, addr, 2924 rv = brcmf_sdiod_ramrw(bus->sdiodev, false, addr,
2940 (u8 *)&sh_val, sizeof(u32)); 2925 (u8 *)&sh_val, sizeof(u32));
2941 if (rv < 0) 2926 if (rv < 0)
2942 return rv; 2927 return rv;
2943 console_size = le32_to_cpu(sh_val); 2928 console_size = le32_to_cpu(sh_val);
2944 2929
2945 addr = sh->console_addr + offsetof(struct rte_console, log_le.idx); 2930 addr = sh->console_addr + offsetof(struct rte_console, log_le.idx);
2946 rv = brcmf_sdio_ramrw(bus->sdiodev, false, addr, 2931 rv = brcmf_sdiod_ramrw(bus->sdiodev, false, addr,
2947 (u8 *)&sh_val, sizeof(u32)); 2932 (u8 *)&sh_val, sizeof(u32));
2948 if (rv < 0) 2933 if (rv < 0)
2949 return rv; 2934 return rv;
2950 console_index = le32_to_cpu(sh_val); 2935 console_index = le32_to_cpu(sh_val);
@@ -2958,8 +2943,8 @@ static int brcmf_sdio_dump_console(struct brcmf_sdio *bus,
2958 2943
2959 /* obtain the console data from device */ 2944 /* obtain the console data from device */
2960 conbuf[console_size] = '\0'; 2945 conbuf[console_size] = '\0';
2961 rv = brcmf_sdio_ramrw(bus->sdiodev, false, console_ptr, (u8 *)conbuf, 2946 rv = brcmf_sdiod_ramrw(bus->sdiodev, false, console_ptr, (u8 *)conbuf,
2962 console_size); 2947 console_size);
2963 if (rv < 0) 2948 if (rv < 0)
2964 goto done; 2949 goto done;
2965 2950
@@ -2996,8 +2981,8 @@ static int brcmf_sdio_trap_info(struct brcmf_sdio *bus, struct sdpcm_shared *sh,
2996 return 0; 2981 return 0;
2997 } 2982 }
2998 2983
2999 error = brcmf_sdio_ramrw(bus->sdiodev, false, sh->trap_addr, (u8 *)&tr, 2984 error = brcmf_sdiod_ramrw(bus->sdiodev, false, sh->trap_addr, (u8 *)&tr,
3000 sizeof(struct brcmf_trap_info)); 2985 sizeof(struct brcmf_trap_info));
3001 if (error < 0) 2986 if (error < 0)
3002 return error; 2987 return error;
3003 2988
@@ -3040,14 +3025,14 @@ static int brcmf_sdio_assert_info(struct brcmf_sdio *bus,
3040 3025
3041 sdio_claim_host(bus->sdiodev->func[1]); 3026 sdio_claim_host(bus->sdiodev->func[1]);
3042 if (sh->assert_file_addr != 0) { 3027 if (sh->assert_file_addr != 0) {
3043 error = brcmf_sdio_ramrw(bus->sdiodev, false, 3028 error = brcmf_sdiod_ramrw(bus->sdiodev, false,
3044 sh->assert_file_addr, (u8 *)file, 80); 3029 sh->assert_file_addr, (u8 *)file, 80);
3045 if (error < 0) 3030 if (error < 0)
3046 return error; 3031 return error;
3047 } 3032 }
3048 if (sh->assert_exp_addr != 0) { 3033 if (sh->assert_exp_addr != 0) {
3049 error = brcmf_sdio_ramrw(bus->sdiodev, false, 3034 error = brcmf_sdiod_ramrw(bus->sdiodev, false,
3050 sh->assert_exp_addr, (u8 *)expr, 80); 3035 sh->assert_exp_addr, (u8 *)expr, 80);
3051 if (error < 0) 3036 if (error < 0)
3052 return error; 3037 return error;
3053 } 3038 }
@@ -3059,7 +3044,7 @@ static int brcmf_sdio_assert_info(struct brcmf_sdio *bus,
3059 return simple_read_from_buffer(data, count, &pos, buf, res); 3044 return simple_read_from_buffer(data, count, &pos, buf, res);
3060} 3045}
3061 3046
3062static int brcmf_sdbrcm_checkdied(struct brcmf_sdio *bus) 3047static int brcmf_sdio_checkdied(struct brcmf_sdio *bus)
3063{ 3048{
3064 int error; 3049 int error;
3065 struct sdpcm_shared sh; 3050 struct sdpcm_shared sh;
@@ -3080,8 +3065,8 @@ static int brcmf_sdbrcm_checkdied(struct brcmf_sdio *bus)
3080 return 0; 3065 return 0;
3081} 3066}
3082 3067
3083static int brcmf_sdbrcm_died_dump(struct brcmf_sdio *bus, char __user *data, 3068static int brcmf_sdio_died_dump(struct brcmf_sdio *bus, char __user *data,
3084 size_t count, loff_t *ppos) 3069 size_t count, loff_t *ppos)
3085{ 3070{
3086 int error = 0; 3071 int error = 0;
3087 struct sdpcm_shared sh; 3072 struct sdpcm_shared sh;
@@ -3122,7 +3107,7 @@ static ssize_t brcmf_sdio_forensic_read(struct file *f, char __user *data,
3122 struct brcmf_sdio *bus = f->private_data; 3107 struct brcmf_sdio *bus = f->private_data;
3123 int res; 3108 int res;
3124 3109
3125 res = brcmf_sdbrcm_died_dump(bus, data, count, ppos); 3110 res = brcmf_sdio_died_dump(bus, data, count, ppos);
3126 if (res > 0) 3111 if (res > 0)
3127 *ppos += res; 3112 *ppos += res;
3128 return (ssize_t)res; 3113 return (ssize_t)res;
@@ -3147,7 +3132,7 @@ static void brcmf_sdio_debugfs_create(struct brcmf_sdio *bus)
3147 brcmf_debugfs_create_sdio_count(drvr, &bus->sdcnt); 3132 brcmf_debugfs_create_sdio_count(drvr, &bus->sdcnt);
3148} 3133}
3149#else 3134#else
3150static int brcmf_sdbrcm_checkdied(struct brcmf_sdio *bus) 3135static int brcmf_sdio_checkdied(struct brcmf_sdio *bus)
3151{ 3136{
3152 return 0; 3137 return 0;
3153} 3138}
@@ -3158,7 +3143,7 @@ static void brcmf_sdio_debugfs_create(struct brcmf_sdio *bus)
3158#endif /* DEBUG */ 3143#endif /* DEBUG */
3159 3144
3160static int 3145static int
3161brcmf_sdbrcm_bus_rxctl(struct device *dev, unsigned char *msg, uint msglen) 3146brcmf_sdio_bus_rxctl(struct device *dev, unsigned char *msg, uint msglen)
3162{ 3147{
3163 int timeleft; 3148 int timeleft;
3164 uint rxlen = 0; 3149 uint rxlen = 0;
@@ -3171,7 +3156,7 @@ brcmf_sdbrcm_bus_rxctl(struct device *dev, unsigned char *msg, uint msglen)
3171 brcmf_dbg(TRACE, "Enter\n"); 3156 brcmf_dbg(TRACE, "Enter\n");
3172 3157
3173 /* Wait until control frame is available */ 3158 /* Wait until control frame is available */
3174 timeleft = brcmf_sdbrcm_dcmd_resp_wait(bus, &bus->rxlen, &pending); 3159 timeleft = brcmf_sdio_dcmd_resp_wait(bus, &bus->rxlen, &pending);
3175 3160
3176 spin_lock_bh(&bus->rxctl_lock); 3161 spin_lock_bh(&bus->rxctl_lock);
3177 rxlen = bus->rxlen; 3162 rxlen = bus->rxlen;
@@ -3188,13 +3173,13 @@ brcmf_sdbrcm_bus_rxctl(struct device *dev, unsigned char *msg, uint msglen)
3188 rxlen, msglen); 3173 rxlen, msglen);
3189 } else if (timeleft == 0) { 3174 } else if (timeleft == 0) {
3190 brcmf_err("resumed on timeout\n"); 3175 brcmf_err("resumed on timeout\n");
3191 brcmf_sdbrcm_checkdied(bus); 3176 brcmf_sdio_checkdied(bus);
3192 } else if (pending) { 3177 } else if (pending) {
3193 brcmf_dbg(CTL, "cancelled\n"); 3178 brcmf_dbg(CTL, "cancelled\n");
3194 return -ERESTARTSYS; 3179 return -ERESTARTSYS;
3195 } else { 3180 } else {
3196 brcmf_dbg(CTL, "resumed for unknown reason?\n"); 3181 brcmf_dbg(CTL, "resumed for unknown reason?\n");
3197 brcmf_sdbrcm_checkdied(bus); 3182 brcmf_sdio_checkdied(bus);
3198 } 3183 }
3199 3184
3200 if (rxlen) 3185 if (rxlen)
@@ -3205,7 +3190,7 @@ brcmf_sdbrcm_bus_rxctl(struct device *dev, unsigned char *msg, uint msglen)
3205 return rxlen ? (int)rxlen : -ETIMEDOUT; 3190 return rxlen ? (int)rxlen : -ETIMEDOUT;
3206} 3191}
3207 3192
3208static bool brcmf_sdbrcm_download_state(struct brcmf_sdio *bus, bool enter) 3193static bool brcmf_sdio_download_state(struct brcmf_sdio *bus, bool enter)
3209{ 3194{
3210 struct chip_info *ci = bus->ci; 3195 struct chip_info *ci = bus->ci;
3211 3196
@@ -3230,7 +3215,7 @@ static bool brcmf_sdbrcm_download_state(struct brcmf_sdio *bus, bool enter)
3230 return true; 3215 return true;
3231} 3216}
3232 3217
3233static int brcmf_sdbrcm_download_code_file(struct brcmf_sdio *bus) 3218static int brcmf_sdio_download_code_file(struct brcmf_sdio *bus)
3234{ 3219{
3235 const struct firmware *fw; 3220 const struct firmware *fw;
3236 int err; 3221 int err;
@@ -3238,7 +3223,7 @@ static int brcmf_sdbrcm_download_code_file(struct brcmf_sdio *bus)
3238 int address; 3223 int address;
3239 int len; 3224 int len;
3240 3225
3241 fw = brcmf_sdbrcm_get_fw(bus, BRCMF_FIRMWARE_BIN); 3226 fw = brcmf_sdio_get_fw(bus, BRCMF_FIRMWARE_BIN);
3242 if (fw == NULL) 3227 if (fw == NULL)
3243 return -ENOENT; 3228 return -ENOENT;
3244 3229
@@ -3252,8 +3237,8 @@ static int brcmf_sdbrcm_download_code_file(struct brcmf_sdio *bus)
3252 while (offset < fw->size) { 3237 while (offset < fw->size) {
3253 len = ((offset + MEMBLOCK) < fw->size) ? MEMBLOCK : 3238 len = ((offset + MEMBLOCK) < fw->size) ? MEMBLOCK :
3254 fw->size - offset; 3239 fw->size - offset;
3255 err = brcmf_sdio_ramrw(bus->sdiodev, true, address, 3240 err = brcmf_sdiod_ramrw(bus->sdiodev, true, address,
3256 (u8 *)&fw->data[offset], len); 3241 (u8 *)&fw->data[offset], len);
3257 if (err) { 3242 if (err) {
3258 brcmf_err("error %d on writing %d membytes at 0x%08x\n", 3243 brcmf_err("error %d on writing %d membytes at 0x%08x\n",
3259 err, len, address); 3244 err, len, address);
@@ -3278,8 +3263,8 @@ failure:
3278 * by two NULs. 3263 * by two NULs.
3279*/ 3264*/
3280 3265
3281static int brcmf_process_nvram_vars(struct brcmf_sdio *bus, 3266static int brcmf_sdio_strip_nvram(struct brcmf_sdio *bus,
3282 const struct firmware *nv) 3267 const struct firmware *nv)
3283{ 3268{
3284 char *varbuf; 3269 char *varbuf;
3285 char *dp; 3270 char *dp;
@@ -3343,44 +3328,48 @@ err:
3343 return ret; 3328 return ret;
3344} 3329}
3345 3330
3346static int brcmf_sdbrcm_download_nvram(struct brcmf_sdio *bus) 3331static int brcmf_sdio_download_nvram(struct brcmf_sdio *bus)
3347{ 3332{
3348 const struct firmware *nv; 3333 const struct firmware *nv;
3349 int ret; 3334 int ret;
3350 3335
3351 nv = brcmf_sdbrcm_get_fw(bus, BRCMF_FIRMWARE_NVRAM); 3336 nv = brcmf_sdio_get_fw(bus, BRCMF_FIRMWARE_NVRAM);
3352 if (nv == NULL) 3337 if (nv == NULL)
3353 return -ENOENT; 3338 return -ENOENT;
3354 3339
3355 ret = brcmf_process_nvram_vars(bus, nv); 3340 ret = brcmf_sdio_strip_nvram(bus, nv);
3356 3341
3357 release_firmware(nv); 3342 release_firmware(nv);
3358 3343
3359 return ret; 3344 return ret;
3360} 3345}
3361 3346
3362static int _brcmf_sdbrcm_download_firmware(struct brcmf_sdio *bus) 3347static int brcmf_sdio_download_firmware(struct brcmf_sdio *bus)
3363{ 3348{
3364 int bcmerror = -1; 3349 int bcmerror = -EFAULT;
3350
3351
3352 sdio_claim_host(bus->sdiodev->func[1]);
3353 brcmf_sdio_clkctl(bus, CLK_AVAIL, false);
3365 3354
3366 /* Keep arm in reset */ 3355 /* Keep arm in reset */
3367 if (!brcmf_sdbrcm_download_state(bus, true)) { 3356 if (!brcmf_sdio_download_state(bus, true)) {
3368 brcmf_err("error placing ARM core in reset\n"); 3357 brcmf_err("error placing ARM core in reset\n");
3369 goto err; 3358 goto err;
3370 } 3359 }
3371 3360
3372 if (brcmf_sdbrcm_download_code_file(bus)) { 3361 if (brcmf_sdio_download_code_file(bus)) {
3373 brcmf_err("dongle image file download failed\n"); 3362 brcmf_err("dongle image file download failed\n");
3374 goto err; 3363 goto err;
3375 } 3364 }
3376 3365
3377 if (brcmf_sdbrcm_download_nvram(bus)) { 3366 if (brcmf_sdio_download_nvram(bus)) {
3378 brcmf_err("dongle nvram file download failed\n"); 3367 brcmf_err("dongle nvram file download failed\n");
3379 goto err; 3368 goto err;
3380 } 3369 }
3381 3370
3382 /* Take arm out of reset */ 3371 /* Take arm out of reset */
3383 if (!brcmf_sdbrcm_download_state(bus, false)) { 3372 if (!brcmf_sdio_download_state(bus, false)) {
3384 brcmf_err("error getting out of ARM core reset\n"); 3373 brcmf_err("error getting out of ARM core reset\n");
3385 goto err; 3374 goto err;
3386 } 3375 }
@@ -3388,10 +3377,12 @@ static int _brcmf_sdbrcm_download_firmware(struct brcmf_sdio *bus)
3388 bcmerror = 0; 3377 bcmerror = 0;
3389 3378
3390err: 3379err:
3380 brcmf_sdio_clkctl(bus, CLK_SDONLY, false);
3381 sdio_release_host(bus->sdiodev->func[1]);
3391 return bcmerror; 3382 return bcmerror;
3392} 3383}
3393 3384
3394static bool brcmf_sdbrcm_sr_capable(struct brcmf_sdio *bus) 3385static bool brcmf_sdio_sr_capable(struct brcmf_sdio *bus)
3395{ 3386{
3396 u32 addr, reg; 3387 u32 addr, reg;
3397 3388
@@ -3403,47 +3394,45 @@ static bool brcmf_sdbrcm_sr_capable(struct brcmf_sdio *bus)
3403 3394
3404 /* read PMU chipcontrol register 3*/ 3395 /* read PMU chipcontrol register 3*/
3405 addr = CORE_CC_REG(bus->ci->c_inf[0].base, chipcontrol_addr); 3396 addr = CORE_CC_REG(bus->ci->c_inf[0].base, chipcontrol_addr);
3406 brcmf_sdio_regwl(bus->sdiodev, addr, 3, NULL); 3397 brcmf_sdiod_regwl(bus->sdiodev, addr, 3, NULL);
3407 addr = CORE_CC_REG(bus->ci->c_inf[0].base, chipcontrol_data); 3398 addr = CORE_CC_REG(bus->ci->c_inf[0].base, chipcontrol_data);
3408 reg = brcmf_sdio_regrl(bus->sdiodev, addr, NULL); 3399 reg = brcmf_sdiod_regrl(bus->sdiodev, addr, NULL);
3409 3400
3410 return (bool)reg; 3401 return (bool)reg;
3411} 3402}
3412 3403
3413static void brcmf_sdbrcm_sr_init(struct brcmf_sdio *bus) 3404static void brcmf_sdio_sr_init(struct brcmf_sdio *bus)
3414{ 3405{
3415 int err = 0; 3406 int err = 0;
3416 u8 val; 3407 u8 val;
3417 3408
3418 brcmf_dbg(TRACE, "Enter\n"); 3409 brcmf_dbg(TRACE, "Enter\n");
3419 3410
3420 val = brcmf_sdio_regrb(bus->sdiodev, SBSDIO_FUNC1_WAKEUPCTRL, 3411 val = brcmf_sdiod_regrb(bus->sdiodev, SBSDIO_FUNC1_WAKEUPCTRL, &err);
3421 &err);
3422 if (err) { 3412 if (err) {
3423 brcmf_err("error reading SBSDIO_FUNC1_WAKEUPCTRL\n"); 3413 brcmf_err("error reading SBSDIO_FUNC1_WAKEUPCTRL\n");
3424 return; 3414 return;
3425 } 3415 }
3426 3416
3427 val |= 1 << SBSDIO_FUNC1_WCTRL_HTWAIT_SHIFT; 3417 val |= 1 << SBSDIO_FUNC1_WCTRL_HTWAIT_SHIFT;
3428 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_WAKEUPCTRL, 3418 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_WAKEUPCTRL, val, &err);
3429 val, &err);
3430 if (err) { 3419 if (err) {
3431 brcmf_err("error writing SBSDIO_FUNC1_WAKEUPCTRL\n"); 3420 brcmf_err("error writing SBSDIO_FUNC1_WAKEUPCTRL\n");
3432 return; 3421 return;
3433 } 3422 }
3434 3423
3435 /* Add CMD14 Support */ 3424 /* Add CMD14 Support */
3436 brcmf_sdio_regwb(bus->sdiodev, SDIO_CCCR_BRCM_CARDCAP, 3425 brcmf_sdiod_regwb(bus->sdiodev, SDIO_CCCR_BRCM_CARDCAP,
3437 (SDIO_CCCR_BRCM_CARDCAP_CMD14_SUPPORT | 3426 (SDIO_CCCR_BRCM_CARDCAP_CMD14_SUPPORT |
3438 SDIO_CCCR_BRCM_CARDCAP_CMD14_EXT), 3427 SDIO_CCCR_BRCM_CARDCAP_CMD14_EXT),
3439 &err); 3428 &err);
3440 if (err) { 3429 if (err) {
3441 brcmf_err("error writing SDIO_CCCR_BRCM_CARDCAP\n"); 3430 brcmf_err("error writing SDIO_CCCR_BRCM_CARDCAP\n");
3442 return; 3431 return;
3443 } 3432 }
3444 3433
3445 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, 3434 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR,
3446 SBSDIO_FORCE_HT, &err); 3435 SBSDIO_FORCE_HT, &err);
3447 if (err) { 3436 if (err) {
3448 brcmf_err("error writing SBSDIO_FUNC1_CHIPCLKCSR\n"); 3437 brcmf_err("error writing SBSDIO_FUNC1_CHIPCLKCSR\n");
3449 return; 3438 return;
@@ -3455,7 +3444,7 @@ static void brcmf_sdbrcm_sr_init(struct brcmf_sdio *bus)
3455} 3444}
3456 3445
3457/* enable KSO bit */ 3446/* enable KSO bit */
3458static int brcmf_sdbrcm_kso_init(struct brcmf_sdio *bus) 3447static int brcmf_sdio_kso_init(struct brcmf_sdio *bus)
3459{ 3448{
3460 u8 val; 3449 u8 val;
3461 int err = 0; 3450 int err = 0;
@@ -3466,8 +3455,7 @@ static int brcmf_sdbrcm_kso_init(struct brcmf_sdio *bus)
3466 if (bus->ci->c_inf[1].rev < 12) 3455 if (bus->ci->c_inf[1].rev < 12)
3467 return 0; 3456 return 0;
3468 3457
3469 val = brcmf_sdio_regrb(bus->sdiodev, SBSDIO_FUNC1_SLEEPCSR, 3458 val = brcmf_sdiod_regrb(bus->sdiodev, SBSDIO_FUNC1_SLEEPCSR, &err);
3470 &err);
3471 if (err) { 3459 if (err) {
3472 brcmf_err("error reading SBSDIO_FUNC1_SLEEPCSR\n"); 3460 brcmf_err("error reading SBSDIO_FUNC1_SLEEPCSR\n");
3473 return err; 3461 return err;
@@ -3476,8 +3464,8 @@ static int brcmf_sdbrcm_kso_init(struct brcmf_sdio *bus)
3476 if (!(val & SBSDIO_FUNC1_SLEEPCSR_KSO_MASK)) { 3464 if (!(val & SBSDIO_FUNC1_SLEEPCSR_KSO_MASK)) {
3477 val |= (SBSDIO_FUNC1_SLEEPCSR_KSO_EN << 3465 val |= (SBSDIO_FUNC1_SLEEPCSR_KSO_EN <<
3478 SBSDIO_FUNC1_SLEEPCSR_KSO_SHIFT); 3466 SBSDIO_FUNC1_SLEEPCSR_KSO_SHIFT);
3479 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_SLEEPCSR, 3467 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_SLEEPCSR,
3480 val, &err); 3468 val, &err);
3481 if (err) { 3469 if (err) {
3482 brcmf_err("error writing SBSDIO_FUNC1_SLEEPCSR\n"); 3470 brcmf_err("error writing SBSDIO_FUNC1_SLEEPCSR\n");
3483 return err; 3471 return err;
@@ -3488,25 +3476,7 @@ static int brcmf_sdbrcm_kso_init(struct brcmf_sdio *bus)
3488} 3476}
3489 3477
3490 3478
3491static bool 3479static int brcmf_sdio_bus_preinit(struct device *dev)
3492brcmf_sdbrcm_download_firmware(struct brcmf_sdio *bus)
3493{
3494 bool ret;
3495
3496 sdio_claim_host(bus->sdiodev->func[1]);
3497
3498 brcmf_sdbrcm_clkctl(bus, CLK_AVAIL, false);
3499
3500 ret = _brcmf_sdbrcm_download_firmware(bus) == 0;
3501
3502 brcmf_sdbrcm_clkctl(bus, CLK_SDONLY, false);
3503
3504 sdio_release_host(bus->sdiodev->func[1]);
3505
3506 return ret;
3507}
3508
3509static int brcmf_sdbrcm_bus_preinit(struct device *dev)
3510{ 3480{
3511 struct brcmf_bus *bus_if = dev_get_drvdata(dev); 3481 struct brcmf_bus *bus_if = dev_get_drvdata(dev);
3512 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio; 3482 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
@@ -3565,13 +3535,11 @@ done:
3565 return err; 3535 return err;
3566} 3536}
3567 3537
3568static int brcmf_sdbrcm_bus_init(struct device *dev) 3538static int brcmf_sdio_bus_init(struct device *dev)
3569{ 3539{
3570 struct brcmf_bus *bus_if = dev_get_drvdata(dev); 3540 struct brcmf_bus *bus_if = dev_get_drvdata(dev);
3571 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio; 3541 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
3572 struct brcmf_sdio *bus = sdiodev->bus; 3542 struct brcmf_sdio *bus = sdiodev->bus;
3573 unsigned long timeout;
3574 u8 ready, enable;
3575 int err, ret = 0; 3543 int err, ret = 0;
3576 u8 saveclk; 3544 u8 saveclk;
3577 3545
@@ -3579,8 +3547,9 @@ static int brcmf_sdbrcm_bus_init(struct device *dev)
3579 3547
3580 /* try to download image and nvram to the dongle */ 3548 /* try to download image and nvram to the dongle */
3581 if (bus_if->state == BRCMF_BUS_DOWN) { 3549 if (bus_if->state == BRCMF_BUS_DOWN) {
3582 if (!(brcmf_sdbrcm_download_firmware(bus))) 3550 err = brcmf_sdio_download_firmware(bus);
3583 return -1; 3551 if (err)
3552 return err;
3584 } 3553 }
3585 3554
3586 if (!bus->sdiodev->bus_if->drvr) 3555 if (!bus->sdiodev->bus_if->drvr)
@@ -3588,21 +3557,21 @@ static int brcmf_sdbrcm_bus_init(struct device *dev)
3588 3557
3589 /* Start the watchdog timer */ 3558 /* Start the watchdog timer */
3590 bus->sdcnt.tickcnt = 0; 3559 bus->sdcnt.tickcnt = 0;
3591 brcmf_sdbrcm_wd_timer(bus, BRCMF_WD_POLL_MS); 3560 brcmf_sdio_wd_timer(bus, BRCMF_WD_POLL_MS);
3592 3561
3593 sdio_claim_host(bus->sdiodev->func[1]); 3562 sdio_claim_host(bus->sdiodev->func[1]);
3594 3563
3595 /* Make sure backplane clock is on, needed to generate F2 interrupt */ 3564 /* Make sure backplane clock is on, needed to generate F2 interrupt */
3596 brcmf_sdbrcm_clkctl(bus, CLK_AVAIL, false); 3565 brcmf_sdio_clkctl(bus, CLK_AVAIL, false);
3597 if (bus->clkstate != CLK_AVAIL) 3566 if (bus->clkstate != CLK_AVAIL)
3598 goto exit; 3567 goto exit;
3599 3568
3600 /* Force clocks on backplane to be sure F2 interrupt propagates */ 3569 /* Force clocks on backplane to be sure F2 interrupt propagates */
3601 saveclk = brcmf_sdio_regrb(bus->sdiodev, 3570 saveclk = brcmf_sdiod_regrb(bus->sdiodev,
3602 SBSDIO_FUNC1_CHIPCLKCSR, &err); 3571 SBSDIO_FUNC1_CHIPCLKCSR, &err);
3603 if (!err) { 3572 if (!err) {
3604 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, 3573 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR,
3605 (saveclk | SBSDIO_FORCE_HT), &err); 3574 (saveclk | SBSDIO_FORCE_HT), &err);
3606 } 3575 }
3607 if (err) { 3576 if (err) {
3608 brcmf_err("Failed to force clock for F2: err %d\n", err); 3577 brcmf_err("Failed to force clock for F2: err %d\n", err);
@@ -3612,56 +3581,42 @@ static int brcmf_sdbrcm_bus_init(struct device *dev)
3612 /* Enable function 2 (frame transfers) */ 3581 /* Enable function 2 (frame transfers) */
3613 w_sdreg32(bus, SDPCM_PROT_VERSION << SMB_DATA_VERSION_SHIFT, 3582 w_sdreg32(bus, SDPCM_PROT_VERSION << SMB_DATA_VERSION_SHIFT,
3614 offsetof(struct sdpcmd_regs, tosbmailboxdata)); 3583 offsetof(struct sdpcmd_regs, tosbmailboxdata));
3615 enable = (SDIO_FUNC_ENABLE_1 | SDIO_FUNC_ENABLE_2); 3584 err = sdio_enable_func(bus->sdiodev->func[SDIO_FUNC_2]);
3616
3617 brcmf_sdio_regwb(bus->sdiodev, SDIO_CCCR_IOEx, enable, NULL);
3618 3585
3619 timeout = jiffies + msecs_to_jiffies(BRCMF_WAIT_F2RDY);
3620 ready = 0;
3621 while (enable != ready) {
3622 ready = brcmf_sdio_regrb(bus->sdiodev,
3623 SDIO_CCCR_IORx, NULL);
3624 if (time_after(jiffies, timeout))
3625 break;
3626 else if (time_after(jiffies, timeout - BRCMF_WAIT_F2RDY + 50))
3627 /* prevent busy waiting if it takes too long */
3628 msleep_interruptible(20);
3629 }
3630 3586
3631 brcmf_dbg(INFO, "enable 0x%02x, ready 0x%02x\n", enable, ready); 3587 brcmf_dbg(INFO, "enable F2: err=%d\n", err);
3632 3588
3633 /* If F2 successfully enabled, set core and enable interrupts */ 3589 /* If F2 successfully enabled, set core and enable interrupts */
3634 if (ready == enable) { 3590 if (!err) {
3635 /* Set up the interrupt mask and enable interrupts */ 3591 /* Set up the interrupt mask and enable interrupts */
3636 bus->hostintmask = HOSTINTMASK; 3592 bus->hostintmask = HOSTINTMASK;
3637 w_sdreg32(bus, bus->hostintmask, 3593 w_sdreg32(bus, bus->hostintmask,
3638 offsetof(struct sdpcmd_regs, hostintmask)); 3594 offsetof(struct sdpcmd_regs, hostintmask));
3639 3595
3640 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_WATERMARK, 8, &err); 3596 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_WATERMARK, 8, &err);
3641 } else { 3597 } else {
3642 /* Disable F2 again */ 3598 /* Disable F2 again */
3643 enable = SDIO_FUNC_ENABLE_1; 3599 sdio_disable_func(bus->sdiodev->func[SDIO_FUNC_2]);
3644 brcmf_sdio_regwb(bus->sdiodev, SDIO_CCCR_IOEx, enable, NULL);
3645 ret = -ENODEV; 3600 ret = -ENODEV;
3646 } 3601 }
3647 3602
3648 if (brcmf_sdbrcm_sr_capable(bus)) { 3603 if (brcmf_sdio_sr_capable(bus)) {
3649 brcmf_sdbrcm_sr_init(bus); 3604 brcmf_sdio_sr_init(bus);
3650 } else { 3605 } else {
3651 /* Restore previous clock setting */ 3606 /* Restore previous clock setting */
3652 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, 3607 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR,
3653 saveclk, &err); 3608 saveclk, &err);
3654 } 3609 }
3655 3610
3656 if (ret == 0) { 3611 if (ret == 0) {
3657 ret = brcmf_sdio_intr_register(bus->sdiodev); 3612 ret = brcmf_sdiod_intr_register(bus->sdiodev);
3658 if (ret != 0) 3613 if (ret != 0)
3659 brcmf_err("intr register failed:%d\n", ret); 3614 brcmf_err("intr register failed:%d\n", ret);
3660 } 3615 }
3661 3616
3662 /* If we didn't come up, turn off backplane clock */ 3617 /* If we didn't come up, turn off backplane clock */
3663 if (bus_if->state != BRCMF_BUS_DATA) 3618 if (bus_if->state != BRCMF_BUS_DATA)
3664 brcmf_sdbrcm_clkctl(bus, CLK_NONE, false); 3619 brcmf_sdio_clkctl(bus, CLK_NONE, false);
3665 3620
3666exit: 3621exit:
3667 sdio_release_host(bus->sdiodev->func[1]); 3622 sdio_release_host(bus->sdiodev->func[1]);
@@ -3669,10 +3624,8 @@ exit:
3669 return ret; 3624 return ret;
3670} 3625}
3671 3626
3672void brcmf_sdbrcm_isr(void *arg) 3627void brcmf_sdio_isr(struct brcmf_sdio *bus)
3673{ 3628{
3674 struct brcmf_sdio *bus = (struct brcmf_sdio *) arg;
3675
3676 brcmf_dbg(TRACE, "Enter\n"); 3629 brcmf_dbg(TRACE, "Enter\n");
3677 3630
3678 if (!bus) { 3631 if (!bus) {
@@ -3702,7 +3655,7 @@ void brcmf_sdbrcm_isr(void *arg)
3702 queue_work(bus->brcmf_wq, &bus->datawork); 3655 queue_work(bus->brcmf_wq, &bus->datawork);
3703} 3656}
3704 3657
3705static bool brcmf_sdbrcm_bus_watchdog(struct brcmf_sdio *bus) 3658static bool brcmf_sdio_bus_watchdog(struct brcmf_sdio *bus)
3706{ 3659{
3707#ifdef DEBUG 3660#ifdef DEBUG
3708 struct brcmf_bus *bus_if = dev_get_drvdata(bus->sdiodev->dev); 3661 struct brcmf_bus *bus_if = dev_get_drvdata(bus->sdiodev->dev);
@@ -3726,9 +3679,9 @@ static bool brcmf_sdbrcm_bus_watchdog(struct brcmf_sdio *bus)
3726 u8 devpend; 3679 u8 devpend;
3727 3680
3728 sdio_claim_host(bus->sdiodev->func[1]); 3681 sdio_claim_host(bus->sdiodev->func[1]);
3729 devpend = brcmf_sdio_regrb(bus->sdiodev, 3682 devpend = brcmf_sdiod_regrb(bus->sdiodev,
3730 SDIO_CCCR_INTx, 3683 SDIO_CCCR_INTx,
3731 NULL); 3684 NULL);
3732 sdio_release_host(bus->sdiodev->func[1]); 3685 sdio_release_host(bus->sdiodev->func[1]);
3733 intstatus = 3686 intstatus =
3734 devpend & (INTR_STATUS_FUNC1 | 3687 devpend & (INTR_STATUS_FUNC1 |
@@ -3758,8 +3711,8 @@ static bool brcmf_sdbrcm_bus_watchdog(struct brcmf_sdio *bus)
3758 bus->console.count -= bus->console_interval; 3711 bus->console.count -= bus->console_interval;
3759 sdio_claim_host(bus->sdiodev->func[1]); 3712 sdio_claim_host(bus->sdiodev->func[1]);
3760 /* Make sure backplane clock is on */ 3713 /* Make sure backplane clock is on */
3761 brcmf_sdbrcm_bus_sleep(bus, false, false); 3714 brcmf_sdio_bus_sleep(bus, false, false);
3762 if (brcmf_sdbrcm_readconsole(bus) < 0) 3715 if (brcmf_sdio_readconsole(bus) < 0)
3763 /* stop on error */ 3716 /* stop on error */
3764 bus->console_interval = 0; 3717 bus->console_interval = 0;
3765 sdio_release_host(bus->sdiodev->func[1]); 3718 sdio_release_host(bus->sdiodev->func[1]);
@@ -3773,11 +3726,11 @@ static bool brcmf_sdbrcm_bus_watchdog(struct brcmf_sdio *bus)
3773 bus->idlecount = 0; 3726 bus->idlecount = 0;
3774 if (bus->activity) { 3727 if (bus->activity) {
3775 bus->activity = false; 3728 bus->activity = false;
3776 brcmf_sdbrcm_wd_timer(bus, BRCMF_WD_POLL_MS); 3729 brcmf_sdio_wd_timer(bus, BRCMF_WD_POLL_MS);
3777 } else { 3730 } else {
3778 brcmf_dbg(SDIO, "idle\n"); 3731 brcmf_dbg(SDIO, "idle\n");
3779 sdio_claim_host(bus->sdiodev->func[1]); 3732 sdio_claim_host(bus->sdiodev->func[1]);
3780 brcmf_sdbrcm_bus_sleep(bus, true, false); 3733 brcmf_sdio_bus_sleep(bus, true, false);
3781 sdio_release_host(bus->sdiodev->func[1]); 3734 sdio_release_host(bus->sdiodev->func[1]);
3782 } 3735 }
3783 } 3736 }
@@ -3792,12 +3745,12 @@ static void brcmf_sdio_dataworker(struct work_struct *work)
3792 datawork); 3745 datawork);
3793 3746
3794 while (atomic_read(&bus->dpc_tskcnt)) { 3747 while (atomic_read(&bus->dpc_tskcnt)) {
3795 brcmf_sdbrcm_dpc(bus); 3748 brcmf_sdio_dpc(bus);
3796 atomic_dec(&bus->dpc_tskcnt); 3749 atomic_dec(&bus->dpc_tskcnt);
3797 } 3750 }
3798} 3751}
3799 3752
3800static void brcmf_sdbrcm_release_malloc(struct brcmf_sdio *bus) 3753static void brcmf_sdio_release_malloc(struct brcmf_sdio *bus)
3801{ 3754{
3802 brcmf_dbg(TRACE, "Enter\n"); 3755 brcmf_dbg(TRACE, "Enter\n");
3803 3756
@@ -3806,7 +3759,7 @@ static void brcmf_sdbrcm_release_malloc(struct brcmf_sdio *bus)
3806 bus->rxlen = 0; 3759 bus->rxlen = 0;
3807} 3760}
3808 3761
3809static bool brcmf_sdbrcm_probe_malloc(struct brcmf_sdio *bus) 3762static bool brcmf_sdio_probe_malloc(struct brcmf_sdio *bus)
3810{ 3763{
3811 brcmf_dbg(TRACE, "Enter\n"); 3764 brcmf_dbg(TRACE, "Enter\n");
3812 3765
@@ -3823,7 +3776,7 @@ static bool brcmf_sdbrcm_probe_malloc(struct brcmf_sdio *bus)
3823} 3776}
3824 3777
3825static bool 3778static bool
3826brcmf_sdbrcm_probe_attach(struct brcmf_sdio *bus, u32 regsva) 3779brcmf_sdio_probe_attach(struct brcmf_sdio *bus)
3827{ 3780{
3828 u8 clkctl = 0; 3781 u8 clkctl = 0;
3829 int err = 0; 3782 int err = 0;
@@ -3836,18 +3789,18 @@ brcmf_sdbrcm_probe_attach(struct brcmf_sdio *bus, u32 regsva)
3836 sdio_claim_host(bus->sdiodev->func[1]); 3789 sdio_claim_host(bus->sdiodev->func[1]);
3837 3790
3838 pr_debug("F1 signature read @0x18000000=0x%4x\n", 3791 pr_debug("F1 signature read @0x18000000=0x%4x\n",
3839 brcmf_sdio_regrl(bus->sdiodev, SI_ENUM_BASE, NULL)); 3792 brcmf_sdiod_regrl(bus->sdiodev, SI_ENUM_BASE, NULL));
3840 3793
3841 /* 3794 /*
3842 * Force PLL off until brcmf_sdio_chip_attach() 3795 * Force PLL off until brcmf_sdio_chip_attach()
3843 * programs PLL control regs 3796 * programs PLL control regs
3844 */ 3797 */
3845 3798
3846 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, 3799 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR,
3847 BRCMF_INIT_CLKCTL1, &err); 3800 BRCMF_INIT_CLKCTL1, &err);
3848 if (!err) 3801 if (!err)
3849 clkctl = brcmf_sdio_regrb(bus->sdiodev, 3802 clkctl = brcmf_sdiod_regrb(bus->sdiodev,
3850 SBSDIO_FUNC1_CHIPCLKCSR, &err); 3803 SBSDIO_FUNC1_CHIPCLKCSR, &err);
3851 3804
3852 if (err || ((clkctl & ~SBSDIO_AVBITS) != BRCMF_INIT_CLKCTL1)) { 3805 if (err || ((clkctl & ~SBSDIO_AVBITS) != BRCMF_INIT_CLKCTL1)) {
3853 brcmf_err("ChipClkCSR access: err %d wrote 0x%02x read 0x%02x\n", 3806 brcmf_err("ChipClkCSR access: err %d wrote 0x%02x read 0x%02x\n",
@@ -3855,12 +3808,12 @@ brcmf_sdbrcm_probe_attach(struct brcmf_sdio *bus, u32 regsva)
3855 goto fail; 3808 goto fail;
3856 } 3809 }
3857 3810
3858 if (brcmf_sdio_chip_attach(bus->sdiodev, &bus->ci, regsva)) { 3811 if (brcmf_sdio_chip_attach(bus->sdiodev, &bus->ci)) {
3859 brcmf_err("brcmf_sdio_chip_attach failed!\n"); 3812 brcmf_err("brcmf_sdio_chip_attach failed!\n");
3860 goto fail; 3813 goto fail;
3861 } 3814 }
3862 3815
3863 if (brcmf_sdbrcm_kso_init(bus)) { 3816 if (brcmf_sdio_kso_init(bus)) {
3864 brcmf_err("error enabling KSO\n"); 3817 brcmf_err("error enabling KSO\n");
3865 goto fail; 3818 goto fail;
3866 } 3819 }
@@ -3879,33 +3832,33 @@ brcmf_sdbrcm_probe_attach(struct brcmf_sdio *bus, u32 regsva)
3879 } 3832 }
3880 3833
3881 /* Set card control so an SDIO card reset does a WLAN backplane reset */ 3834 /* Set card control so an SDIO card reset does a WLAN backplane reset */
3882 reg_val = brcmf_sdio_regrb(bus->sdiodev, 3835 reg_val = brcmf_sdiod_regrb(bus->sdiodev,
3883 SDIO_CCCR_BRCM_CARDCTRL, &err); 3836 SDIO_CCCR_BRCM_CARDCTRL, &err);
3884 if (err) 3837 if (err)
3885 goto fail; 3838 goto fail;
3886 3839
3887 reg_val |= SDIO_CCCR_BRCM_CARDCTRL_WLANRESET; 3840 reg_val |= SDIO_CCCR_BRCM_CARDCTRL_WLANRESET;
3888 3841
3889 brcmf_sdio_regwb(bus->sdiodev, 3842 brcmf_sdiod_regwb(bus->sdiodev,
3890 SDIO_CCCR_BRCM_CARDCTRL, reg_val, &err); 3843 SDIO_CCCR_BRCM_CARDCTRL, reg_val, &err);
3891 if (err) 3844 if (err)
3892 goto fail; 3845 goto fail;
3893 3846
3894 /* set PMUControl so a backplane reset does PMU state reload */ 3847 /* set PMUControl so a backplane reset does PMU state reload */
3895 reg_addr = CORE_CC_REG(bus->ci->c_inf[0].base, 3848 reg_addr = CORE_CC_REG(bus->ci->c_inf[0].base,
3896 pmucontrol); 3849 pmucontrol);
3897 reg_val = brcmf_sdio_regrl(bus->sdiodev, 3850 reg_val = brcmf_sdiod_regrl(bus->sdiodev,
3898 reg_addr, 3851 reg_addr,
3899 &err); 3852 &err);
3900 if (err) 3853 if (err)
3901 goto fail; 3854 goto fail;
3902 3855
3903 reg_val |= (BCMA_CC_PMU_CTL_RES_RELOAD << BCMA_CC_PMU_CTL_RES_SHIFT); 3856 reg_val |= (BCMA_CC_PMU_CTL_RES_RELOAD << BCMA_CC_PMU_CTL_RES_SHIFT);
3904 3857
3905 brcmf_sdio_regwl(bus->sdiodev, 3858 brcmf_sdiod_regwl(bus->sdiodev,
3906 reg_addr, 3859 reg_addr,
3907 reg_val, 3860 reg_val,
3908 &err); 3861 &err);
3909 if (err) 3862 if (err)
3910 goto fail; 3863 goto fail;
3911 3864
@@ -3935,21 +3888,20 @@ fail:
3935 return false; 3888 return false;
3936} 3889}
3937 3890
3938static bool brcmf_sdbrcm_probe_init(struct brcmf_sdio *bus) 3891static bool brcmf_sdio_probe_init(struct brcmf_sdio *bus)
3939{ 3892{
3940 brcmf_dbg(TRACE, "Enter\n"); 3893 brcmf_dbg(TRACE, "Enter\n");
3941 3894
3942 sdio_claim_host(bus->sdiodev->func[1]); 3895 sdio_claim_host(bus->sdiodev->func[1]);
3943 3896
3944 /* Disable F2 to clear any intermediate frame state on the dongle */ 3897 /* Disable F2 to clear any intermediate frame state on the dongle */
3945 brcmf_sdio_regwb(bus->sdiodev, SDIO_CCCR_IOEx, 3898 sdio_disable_func(bus->sdiodev->func[SDIO_FUNC_2]);
3946 SDIO_FUNC_ENABLE_1, NULL);
3947 3899
3948 bus->sdiodev->bus_if->state = BRCMF_BUS_DOWN; 3900 bus->sdiodev->bus_if->state = BRCMF_BUS_DOWN;
3949 bus->rxflow = false; 3901 bus->rxflow = false;
3950 3902
3951 /* Done with backplane-dependent accesses, can drop clock... */ 3903 /* Done with backplane-dependent accesses, can drop clock... */
3952 brcmf_sdio_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, 0, NULL); 3904 brcmf_sdiod_regwb(bus->sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, 0, NULL);
3953 3905
3954 sdio_release_host(bus->sdiodev->func[1]); 3906 sdio_release_host(bus->sdiodev->func[1]);
3955 3907
@@ -3970,7 +3922,7 @@ static bool brcmf_sdbrcm_probe_init(struct brcmf_sdio *bus)
3970} 3922}
3971 3923
3972static int 3924static int
3973brcmf_sdbrcm_watchdog_thread(void *data) 3925brcmf_sdio_watchdog_thread(void *data)
3974{ 3926{
3975 struct brcmf_sdio *bus = (struct brcmf_sdio *)data; 3927 struct brcmf_sdio *bus = (struct brcmf_sdio *)data;
3976 3928
@@ -3980,7 +3932,7 @@ brcmf_sdbrcm_watchdog_thread(void *data)
3980 if (kthread_should_stop()) 3932 if (kthread_should_stop())
3981 break; 3933 break;
3982 if (!wait_for_completion_interruptible(&bus->watchdog_wait)) { 3934 if (!wait_for_completion_interruptible(&bus->watchdog_wait)) {
3983 brcmf_sdbrcm_bus_watchdog(bus); 3935 brcmf_sdio_bus_watchdog(bus);
3984 /* Count the tick for reference */ 3936 /* Count the tick for reference */
3985 bus->sdcnt.tickcnt++; 3937 bus->sdcnt.tickcnt++;
3986 } else 3938 } else
@@ -3990,7 +3942,7 @@ brcmf_sdbrcm_watchdog_thread(void *data)
3990} 3942}
3991 3943
3992static void 3944static void
3993brcmf_sdbrcm_watchdog(unsigned long data) 3945brcmf_sdio_watchdog(unsigned long data)
3994{ 3946{
3995 struct brcmf_sdio *bus = (struct brcmf_sdio *)data; 3947 struct brcmf_sdio *bus = (struct brcmf_sdio *)data;
3996 3948
@@ -4003,14 +3955,14 @@ brcmf_sdbrcm_watchdog(unsigned long data)
4003 } 3955 }
4004} 3956}
4005 3957
4006static void brcmf_sdbrcm_release_dongle(struct brcmf_sdio *bus) 3958static void brcmf_sdio_release_dongle(struct brcmf_sdio *bus)
4007{ 3959{
4008 brcmf_dbg(TRACE, "Enter\n"); 3960 brcmf_dbg(TRACE, "Enter\n");
4009 3961
4010 if (bus->ci) { 3962 if (bus->ci) {
4011 sdio_claim_host(bus->sdiodev->func[1]); 3963 sdio_claim_host(bus->sdiodev->func[1]);
4012 brcmf_sdbrcm_clkctl(bus, CLK_AVAIL, false); 3964 brcmf_sdio_clkctl(bus, CLK_AVAIL, false);
4013 brcmf_sdbrcm_clkctl(bus, CLK_NONE, false); 3965 brcmf_sdio_clkctl(bus, CLK_NONE, false);
4014 sdio_release_host(bus->sdiodev->func[1]); 3966 sdio_release_host(bus->sdiodev->func[1]);
4015 brcmf_sdio_chip_detach(&bus->ci); 3967 brcmf_sdio_chip_detach(&bus->ci);
4016 if (bus->vars && bus->varsz) 3968 if (bus->vars && bus->varsz)
@@ -4021,53 +3973,23 @@ static void brcmf_sdbrcm_release_dongle(struct brcmf_sdio *bus)
4021 brcmf_dbg(TRACE, "Disconnected\n"); 3973 brcmf_dbg(TRACE, "Disconnected\n");
4022} 3974}
4023 3975
4024/* Detach and free everything */
4025static void brcmf_sdbrcm_release(struct brcmf_sdio *bus)
4026{
4027 brcmf_dbg(TRACE, "Enter\n");
4028
4029 if (bus) {
4030 /* De-register interrupt handler */
4031 brcmf_sdio_intr_unregister(bus->sdiodev);
4032
4033 cancel_work_sync(&bus->datawork);
4034 if (bus->brcmf_wq)
4035 destroy_workqueue(bus->brcmf_wq);
4036
4037 if (bus->sdiodev->bus_if->drvr) {
4038 brcmf_detach(bus->sdiodev->dev);
4039 brcmf_sdbrcm_release_dongle(bus);
4040 }
4041
4042 brcmu_pkt_buf_free_skb(bus->txglom_sgpad);
4043 brcmf_sdbrcm_release_malloc(bus);
4044 kfree(bus->hdrbuf);
4045 kfree(bus);
4046 }
4047
4048 brcmf_dbg(TRACE, "Disconnected\n");
4049}
4050
4051static struct brcmf_bus_ops brcmf_sdio_bus_ops = { 3976static struct brcmf_bus_ops brcmf_sdio_bus_ops = {
4052 .stop = brcmf_sdbrcm_bus_stop, 3977 .stop = brcmf_sdio_bus_stop,
4053 .preinit = brcmf_sdbrcm_bus_preinit, 3978 .preinit = brcmf_sdio_bus_preinit,
4054 .init = brcmf_sdbrcm_bus_init, 3979 .init = brcmf_sdio_bus_init,
4055 .txdata = brcmf_sdbrcm_bus_txdata, 3980 .txdata = brcmf_sdio_bus_txdata,
4056 .txctl = brcmf_sdbrcm_bus_txctl, 3981 .txctl = brcmf_sdio_bus_txctl,
4057 .rxctl = brcmf_sdbrcm_bus_rxctl, 3982 .rxctl = brcmf_sdio_bus_rxctl,
4058 .gettxq = brcmf_sdbrcm_bus_gettxq, 3983 .gettxq = brcmf_sdio_bus_gettxq,
4059}; 3984};
4060 3985
4061void *brcmf_sdbrcm_probe(u32 regsva, struct brcmf_sdio_dev *sdiodev) 3986struct brcmf_sdio *brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
4062{ 3987{
4063 int ret; 3988 int ret;
4064 struct brcmf_sdio *bus; 3989 struct brcmf_sdio *bus;
4065 3990
4066 brcmf_dbg(TRACE, "Enter\n"); 3991 brcmf_dbg(TRACE, "Enter\n");
4067 3992
4068 /* We make an assumption about address window mappings:
4069 * regsva == SI_ENUM_BASE*/
4070
4071 /* Allocate private bus interface state */ 3993 /* Allocate private bus interface state */
4072 bus = kzalloc(sizeof(struct brcmf_sdio), GFP_ATOMIC); 3994 bus = kzalloc(sizeof(struct brcmf_sdio), GFP_ATOMIC);
4073 if (!bus) 3995 if (!bus)
@@ -4101,8 +4023,8 @@ void *brcmf_sdbrcm_probe(u32 regsva, struct brcmf_sdio_dev *sdiodev)
4101 } 4023 }
4102 4024
4103 /* attempt to attach to the dongle */ 4025 /* attempt to attach to the dongle */
4104 if (!(brcmf_sdbrcm_probe_attach(bus, regsva))) { 4026 if (!(brcmf_sdio_probe_attach(bus))) {
4105 brcmf_err("brcmf_sdbrcm_probe_attach failed\n"); 4027 brcmf_err("brcmf_sdio_probe_attach failed\n");
4106 goto fail; 4028 goto fail;
4107 } 4029 }
4108 4030
@@ -4114,11 +4036,11 @@ void *brcmf_sdbrcm_probe(u32 regsva, struct brcmf_sdio_dev *sdiodev)
4114 /* Set up the watchdog timer */ 4036 /* Set up the watchdog timer */
4115 init_timer(&bus->timer); 4037 init_timer(&bus->timer);
4116 bus->timer.data = (unsigned long)bus; 4038 bus->timer.data = (unsigned long)bus;
4117 bus->timer.function = brcmf_sdbrcm_watchdog; 4039 bus->timer.function = brcmf_sdio_watchdog;
4118 4040
4119 /* Initialize watchdog thread */ 4041 /* Initialize watchdog thread */
4120 init_completion(&bus->watchdog_wait); 4042 init_completion(&bus->watchdog_wait);
4121 bus->watchdog_tsk = kthread_run(brcmf_sdbrcm_watchdog_thread, 4043 bus->watchdog_tsk = kthread_run(brcmf_sdio_watchdog_thread,
4122 bus, "brcmf_watchdog"); 4044 bus, "brcmf_watchdog");
4123 if (IS_ERR(bus->watchdog_tsk)) { 4045 if (IS_ERR(bus->watchdog_tsk)) {
4124 pr_warn("brcmf_watchdog thread failed to start\n"); 4046 pr_warn("brcmf_watchdog thread failed to start\n");
@@ -4144,13 +4066,13 @@ void *brcmf_sdbrcm_probe(u32 regsva, struct brcmf_sdio_dev *sdiodev)
4144 } 4066 }
4145 4067
4146 /* Allocate buffers */ 4068 /* Allocate buffers */
4147 if (!(brcmf_sdbrcm_probe_malloc(bus))) { 4069 if (!(brcmf_sdio_probe_malloc(bus))) {
4148 brcmf_err("brcmf_sdbrcm_probe_malloc failed\n"); 4070 brcmf_err("brcmf_sdio_probe_malloc failed\n");
4149 goto fail; 4071 goto fail;
4150 } 4072 }
4151 4073
4152 if (!(brcmf_sdbrcm_probe_init(bus))) { 4074 if (!(brcmf_sdio_probe_init(bus))) {
4153 brcmf_err("brcmf_sdbrcm_probe_init failed\n"); 4075 brcmf_err("brcmf_sdio_probe_init failed\n");
4154 goto fail; 4076 goto fail;
4155 } 4077 }
4156 4078
@@ -4167,24 +4089,38 @@ void *brcmf_sdbrcm_probe(u32 regsva, struct brcmf_sdio_dev *sdiodev)
4167 return bus; 4089 return bus;
4168 4090
4169fail: 4091fail:
4170 brcmf_sdbrcm_release(bus); 4092 brcmf_sdio_remove(bus);
4171 return NULL; 4093 return NULL;
4172} 4094}
4173 4095
4174void brcmf_sdbrcm_disconnect(void *ptr) 4096/* Detach and free everything */
4097void brcmf_sdio_remove(struct brcmf_sdio *bus)
4175{ 4098{
4176 struct brcmf_sdio *bus = (struct brcmf_sdio *)ptr;
4177
4178 brcmf_dbg(TRACE, "Enter\n"); 4099 brcmf_dbg(TRACE, "Enter\n");
4179 4100
4180 if (bus) 4101 if (bus) {
4181 brcmf_sdbrcm_release(bus); 4102 /* De-register interrupt handler */
4103 brcmf_sdiod_intr_unregister(bus->sdiodev);
4104
4105 cancel_work_sync(&bus->datawork);
4106 if (bus->brcmf_wq)
4107 destroy_workqueue(bus->brcmf_wq);
4108
4109 if (bus->sdiodev->bus_if->drvr) {
4110 brcmf_detach(bus->sdiodev->dev);
4111 brcmf_sdio_release_dongle(bus);
4112 }
4113
4114 brcmu_pkt_buf_free_skb(bus->txglom_sgpad);
4115 brcmf_sdio_release_malloc(bus);
4116 kfree(bus->hdrbuf);
4117 kfree(bus);
4118 }
4182 4119
4183 brcmf_dbg(TRACE, "Disconnected\n"); 4120 brcmf_dbg(TRACE, "Disconnected\n");
4184} 4121}
4185 4122
4186void 4123void brcmf_sdio_wd_timer(struct brcmf_sdio *bus, uint wdtick)
4187brcmf_sdbrcm_wd_timer(struct brcmf_sdio *bus, uint wdtick)
4188{ 4124{
4189 /* Totally stop the timer */ 4125 /* Totally stop the timer */
4190 if (!wdtick && bus->wd_timer_valid) { 4126 if (!wdtick && bus->wd_timer_valid) {
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/fwil.c b/drivers/net/wireless/brcm80211/brcmfmac/fwil.c
index b72d3395499a..22adbe311d20 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/fwil.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/fwil.c
@@ -68,7 +68,7 @@ brcmf_fil_cmd_data_set(struct brcmf_if *ifp, u32 cmd, void *data, u32 len)
68 68
69 brcmf_dbg(FIL, "cmd=%d, len=%d\n", cmd, len); 69 brcmf_dbg(FIL, "cmd=%d, len=%d\n", cmd, len);
70 brcmf_dbg_hex_dump(BRCMF_FIL_ON(), data, 70 brcmf_dbg_hex_dump(BRCMF_FIL_ON(), data,
71 min_t(uint, len, MAX_HEX_DUMP_LEN), "data"); 71 min_t(uint, len, MAX_HEX_DUMP_LEN), "data\n");
72 72
73 err = brcmf_fil_cmd_data(ifp, cmd, data, len, true); 73 err = brcmf_fil_cmd_data(ifp, cmd, data, len, true);
74 mutex_unlock(&ifp->drvr->proto_block); 74 mutex_unlock(&ifp->drvr->proto_block);
@@ -86,7 +86,7 @@ brcmf_fil_cmd_data_get(struct brcmf_if *ifp, u32 cmd, void *data, u32 len)
86 86
87 brcmf_dbg(FIL, "cmd=%d, len=%d\n", cmd, len); 87 brcmf_dbg(FIL, "cmd=%d, len=%d\n", cmd, len);
88 brcmf_dbg_hex_dump(BRCMF_FIL_ON(), data, 88 brcmf_dbg_hex_dump(BRCMF_FIL_ON(), data,
89 min_t(uint, len, MAX_HEX_DUMP_LEN), "data"); 89 min_t(uint, len, MAX_HEX_DUMP_LEN), "data\n");
90 90
91 mutex_unlock(&ifp->drvr->proto_block); 91 mutex_unlock(&ifp->drvr->proto_block);
92 92
@@ -155,7 +155,7 @@ brcmf_fil_iovar_data_set(struct brcmf_if *ifp, char *name, void *data,
155 155
156 brcmf_dbg(FIL, "name=%s, len=%d\n", name, len); 156 brcmf_dbg(FIL, "name=%s, len=%d\n", name, len);
157 brcmf_dbg_hex_dump(BRCMF_FIL_ON(), data, 157 brcmf_dbg_hex_dump(BRCMF_FIL_ON(), data,
158 min_t(uint, len, MAX_HEX_DUMP_LEN), "data"); 158 min_t(uint, len, MAX_HEX_DUMP_LEN), "data\n");
159 159
160 buflen = brcmf_create_iovar(name, data, len, drvr->proto_buf, 160 buflen = brcmf_create_iovar(name, data, len, drvr->proto_buf,
161 sizeof(drvr->proto_buf)); 161 sizeof(drvr->proto_buf));
@@ -195,7 +195,7 @@ brcmf_fil_iovar_data_get(struct brcmf_if *ifp, char *name, void *data,
195 195
196 brcmf_dbg(FIL, "name=%s, len=%d\n", name, len); 196 brcmf_dbg(FIL, "name=%s, len=%d\n", name, len);
197 brcmf_dbg_hex_dump(BRCMF_FIL_ON(), data, 197 brcmf_dbg_hex_dump(BRCMF_FIL_ON(), data,
198 min_t(uint, len, MAX_HEX_DUMP_LEN), "data"); 198 min_t(uint, len, MAX_HEX_DUMP_LEN), "data\n");
199 199
200 mutex_unlock(&drvr->proto_block); 200 mutex_unlock(&drvr->proto_block);
201 return err; 201 return err;
@@ -278,7 +278,7 @@ brcmf_fil_bsscfg_data_set(struct brcmf_if *ifp, char *name,
278 278
279 brcmf_dbg(FIL, "bssidx=%d, name=%s, len=%d\n", ifp->bssidx, name, len); 279 brcmf_dbg(FIL, "bssidx=%d, name=%s, len=%d\n", ifp->bssidx, name, len);
280 brcmf_dbg_hex_dump(BRCMF_FIL_ON(), data, 280 brcmf_dbg_hex_dump(BRCMF_FIL_ON(), data,
281 min_t(uint, len, MAX_HEX_DUMP_LEN), "data"); 281 min_t(uint, len, MAX_HEX_DUMP_LEN), "data\n");
282 282
283 buflen = brcmf_create_bsscfg(ifp->bssidx, name, data, len, 283 buflen = brcmf_create_bsscfg(ifp->bssidx, name, data, len,
284 drvr->proto_buf, sizeof(drvr->proto_buf)); 284 drvr->proto_buf, sizeof(drvr->proto_buf));
@@ -317,7 +317,7 @@ brcmf_fil_bsscfg_data_get(struct brcmf_if *ifp, char *name,
317 } 317 }
318 brcmf_dbg(FIL, "bssidx=%d, name=%s, len=%d\n", ifp->bssidx, name, len); 318 brcmf_dbg(FIL, "bssidx=%d, name=%s, len=%d\n", ifp->bssidx, name, len);
319 brcmf_dbg_hex_dump(BRCMF_FIL_ON(), data, 319 brcmf_dbg_hex_dump(BRCMF_FIL_ON(), data,
320 min_t(uint, len, MAX_HEX_DUMP_LEN), "data"); 320 min_t(uint, len, MAX_HEX_DUMP_LEN), "data\n");
321 321
322 mutex_unlock(&drvr->proto_block); 322 mutex_unlock(&drvr->proto_block);
323 return err; 323 return err;
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/fwsignal.c b/drivers/net/wireless/brcm80211/brcmfmac/fwsignal.c
index e9bdfdb95d8f..7918c1033662 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/fwsignal.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/fwsignal.c
@@ -838,7 +838,7 @@ static void brcmf_fws_cleanup(struct brcmf_fws_info *fws, int ifidx)
838 brcmf_fws_hanger_cleanup(fws, matchfn, ifidx); 838 brcmf_fws_hanger_cleanup(fws, matchfn, ifidx);
839} 839}
840 840
841static int brcmf_fws_hdrpush(struct brcmf_fws_info *fws, struct sk_buff *skb) 841static u8 brcmf_fws_hdrpush(struct brcmf_fws_info *fws, struct sk_buff *skb)
842{ 842{
843 struct brcmf_fws_mac_descriptor *entry = brcmf_skbcb(skb)->mac; 843 struct brcmf_fws_mac_descriptor *entry = brcmf_skbcb(skb)->mac;
844 u8 *wlh; 844 u8 *wlh;
@@ -887,9 +887,7 @@ static int brcmf_fws_hdrpush(struct brcmf_fws_info *fws, struct sk_buff *skb)
887 if (fillers) 887 if (fillers)
888 memset(wlh, BRCMF_FWS_TYPE_FILLER, fillers); 888 memset(wlh, BRCMF_FWS_TYPE_FILLER, fillers);
889 889
890 brcmf_proto_hdrpush(fws->drvr, brcmf_skb_if_flags_get_field(skb, INDEX), 890 return (u8)(data_offset >> 2);
891 data_offset >> 2, skb);
892 return 0;
893} 891}
894 892
895static bool brcmf_fws_tim_update(struct brcmf_fws_info *fws, 893static bool brcmf_fws_tim_update(struct brcmf_fws_info *fws,
@@ -897,10 +895,11 @@ static bool brcmf_fws_tim_update(struct brcmf_fws_info *fws,
897 int fifo, bool send_immediately) 895 int fifo, bool send_immediately)
898{ 896{
899 struct sk_buff *skb; 897 struct sk_buff *skb;
900 struct brcmf_bus *bus;
901 struct brcmf_skbuff_cb *skcb; 898 struct brcmf_skbuff_cb *skcb;
902 s32 err; 899 s32 err;
903 u32 len; 900 u32 len;
901 u8 data_offset;
902 int ifidx;
904 903
905 /* check delayedQ and suppressQ in one call using bitmap */ 904 /* check delayedQ and suppressQ in one call using bitmap */
906 if (brcmu_pktq_mlen(&entry->psq, 3 << (fifo * 2)) == 0) 905 if (brcmu_pktq_mlen(&entry->psq, 3 << (fifo * 2)) == 0)
@@ -928,13 +927,11 @@ static bool brcmf_fws_tim_update(struct brcmf_fws_info *fws,
928 skcb->state = BRCMF_FWS_SKBSTATE_TIM; 927 skcb->state = BRCMF_FWS_SKBSTATE_TIM;
929 skcb->htod = 0; 928 skcb->htod = 0;
930 skcb->htod_seq = 0; 929 skcb->htod_seq = 0;
931 bus = fws->drvr->bus_if; 930 data_offset = brcmf_fws_hdrpush(fws, skb);
932 err = brcmf_fws_hdrpush(fws, skb); 931 ifidx = brcmf_skb_if_flags_get_field(skb, INDEX);
933 if (err == 0) { 932 brcmf_fws_unlock(fws);
934 brcmf_fws_unlock(fws); 933 err = brcmf_proto_txdata(fws->drvr, ifidx, data_offset, skb);
935 err = brcmf_bus_txdata(bus, skb); 934 brcmf_fws_lock(fws);
936 brcmf_fws_lock(fws);
937 }
938 if (err) 935 if (err)
939 brcmu_pkt_buf_free_skb(skb); 936 brcmu_pkt_buf_free_skb(skb);
940 return true; 937 return true;
@@ -1393,7 +1390,7 @@ static int brcmf_fws_txstatus_suppressed(struct brcmf_fws_info *fws, int fifo,
1393 entry->generation = genbit; 1390 entry->generation = genbit;
1394 1391
1395 ret = brcmf_proto_hdrpull(fws->drvr, false, &ifidx, skb); 1392 ret = brcmf_proto_hdrpull(fws->drvr, false, &ifidx, skb);
1396 if (ret == 0) 1393 if (ret == 0) {
1397 brcmf_skb_htod_tag_set_field(skb, GENERATION, genbit); 1394 brcmf_skb_htod_tag_set_field(skb, GENERATION, genbit);
1398 brcmf_skbcb(skb)->htod_seq = seq; 1395 brcmf_skbcb(skb)->htod_seq = seq;
1399 if (brcmf_skb_htod_seq_get_field(skb, FROMFW)) { 1396 if (brcmf_skb_htod_seq_get_field(skb, FROMFW)) {
@@ -1404,6 +1401,8 @@ static int brcmf_fws_txstatus_suppressed(struct brcmf_fws_info *fws, int fifo,
1404 } 1401 }
1405 ret = brcmf_fws_enq(fws, BRCMF_FWS_SKBSTATE_SUPPRESSED, fifo, 1402 ret = brcmf_fws_enq(fws, BRCMF_FWS_SKBSTATE_SUPPRESSED, fifo,
1406 skb); 1403 skb);
1404 }
1405
1407 if (ret != 0) { 1406 if (ret != 0) {
1408 /* suppress q is full or hdrpull failed, drop this packet */ 1407 /* suppress q is full or hdrpull failed, drop this packet */
1409 brcmf_fws_hanger_poppkt(&fws->hanger, hslot, &skb, 1408 brcmf_fws_hanger_poppkt(&fws->hanger, hslot, &skb,
@@ -1717,7 +1716,7 @@ int brcmf_fws_hdrpull(struct brcmf_pub *drvr, int ifidx, s16 signal_len,
1717 return 0; 1716 return 0;
1718} 1717}
1719 1718
1720static void brcmf_fws_precommit_skb(struct brcmf_fws_info *fws, int fifo, 1719static u8 brcmf_fws_precommit_skb(struct brcmf_fws_info *fws, int fifo,
1721 struct sk_buff *p) 1720 struct sk_buff *p)
1722{ 1721{
1723 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(p); 1722 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(p);
@@ -1735,7 +1734,7 @@ static void brcmf_fws_precommit_skb(struct brcmf_fws_info *fws, int fifo,
1735 flags |= BRCMF_FWS_HTOD_FLAG_PKT_REQUESTED; 1734 flags |= BRCMF_FWS_HTOD_FLAG_PKT_REQUESTED;
1736 } 1735 }
1737 brcmf_skb_htod_tag_set_field(p, FLAGS, flags); 1736 brcmf_skb_htod_tag_set_field(p, FLAGS, flags);
1738 brcmf_fws_hdrpush(fws, p); 1737 return brcmf_fws_hdrpush(fws, p);
1739} 1738}
1740 1739
1741static void brcmf_fws_rollback_toq(struct brcmf_fws_info *fws, 1740static void brcmf_fws_rollback_toq(struct brcmf_fws_info *fws,
@@ -1803,20 +1802,21 @@ static int brcmf_fws_commit_skb(struct brcmf_fws_info *fws, int fifo,
1803{ 1802{
1804 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(skb); 1803 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(skb);
1805 struct brcmf_fws_mac_descriptor *entry; 1804 struct brcmf_fws_mac_descriptor *entry;
1806 struct brcmf_bus *bus = fws->drvr->bus_if;
1807 int rc; 1805 int rc;
1808 u8 ifidx; 1806 u8 ifidx;
1807 u8 data_offset;
1809 1808
1810 entry = skcb->mac; 1809 entry = skcb->mac;
1811 if (IS_ERR(entry)) 1810 if (IS_ERR(entry))
1812 return PTR_ERR(entry); 1811 return PTR_ERR(entry);
1813 1812
1814 brcmf_fws_precommit_skb(fws, fifo, skb); 1813 data_offset = brcmf_fws_precommit_skb(fws, fifo, skb);
1815 entry->transit_count++; 1814 entry->transit_count++;
1816 if (entry->suppressed) 1815 if (entry->suppressed)
1817 entry->suppr_transit_count++; 1816 entry->suppr_transit_count++;
1817 ifidx = brcmf_skb_if_flags_get_field(skb, INDEX);
1818 brcmf_fws_unlock(fws); 1818 brcmf_fws_unlock(fws);
1819 rc = brcmf_bus_txdata(bus, skb); 1819 rc = brcmf_proto_txdata(fws->drvr, ifidx, data_offset, skb);
1820 brcmf_fws_lock(fws); 1820 brcmf_fws_lock(fws);
1821 brcmf_dbg(DATA, "%s flags %X htod %X bus_tx %d\n", entry->name, 1821 brcmf_dbg(DATA, "%s flags %X htod %X bus_tx %d\n", entry->name,
1822 skcb->if_flags, skcb->htod, rc); 1822 skcb->if_flags, skcb->htod, rc);
@@ -1977,10 +1977,9 @@ static void brcmf_fws_dequeue_worker(struct work_struct *worker)
1977 &skb, true); 1977 &skb, true);
1978 ifidx = brcmf_skb_if_flags_get_field(skb, 1978 ifidx = brcmf_skb_if_flags_get_field(skb,
1979 INDEX); 1979 INDEX);
1980 brcmf_proto_hdrpush(drvr, ifidx, 0, skb); 1980 /* Use proto layer to send data frame */
1981 /* Use bus module to send data frame */
1982 brcmf_fws_unlock(fws); 1981 brcmf_fws_unlock(fws);
1983 ret = brcmf_bus_txdata(drvr->bus_if, skb); 1982 ret = brcmf_proto_txdata(drvr, ifidx, 0, skb);
1984 brcmf_fws_lock(fws); 1983 brcmf_fws_lock(fws);
1985 if (ret < 0) 1984 if (ret < 0)
1986 brcmf_txfinalize(drvr, skb, false); 1985 brcmf_txfinalize(drvr, skb, false);
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/proto.c b/drivers/net/wireless/brcm80211/brcmfmac/proto.c
index 87eb2bd4c072..b6b464184946 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/proto.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/proto.c
@@ -39,7 +39,7 @@ int brcmf_proto_attach(struct brcmf_pub *drvr)
39 if (brcmf_proto_bcdc_attach(drvr)) 39 if (brcmf_proto_bcdc_attach(drvr))
40 goto fail; 40 goto fail;
41 41
42 if ((proto->hdrpush == NULL) || (proto->hdrpull == NULL) || 42 if ((proto->txdata == NULL) || (proto->hdrpull == NULL) ||
43 (proto->query_dcmd == NULL) || (proto->set_dcmd == NULL)) { 43 (proto->query_dcmd == NULL) || (proto->set_dcmd == NULL)) {
44 brcmf_err("Not all proto handlers have been installed\n"); 44 brcmf_err("Not all proto handlers have been installed\n");
45 goto fail; 45 goto fail;
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/proto.h b/drivers/net/wireless/brcm80211/brcmfmac/proto.h
index 8de1b3bce228..482fb0ba4a30 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/proto.h
+++ b/drivers/net/wireless/brcm80211/brcmfmac/proto.h
@@ -17,14 +17,14 @@
17#define BRCMFMAC_PROTO_H 17#define BRCMFMAC_PROTO_H
18 18
19struct brcmf_proto { 19struct brcmf_proto {
20 void (*hdrpush)(struct brcmf_pub *drvr, int ifidx, u8 offset,
21 struct sk_buff *skb);
22 int (*hdrpull)(struct brcmf_pub *drvr, bool do_fws, u8 *ifidx, 20 int (*hdrpull)(struct brcmf_pub *drvr, bool do_fws, u8 *ifidx,
23 struct sk_buff *skb); 21 struct sk_buff *skb);
24 int (*query_dcmd)(struct brcmf_pub *drvr, int ifidx, uint cmd, 22 int (*query_dcmd)(struct brcmf_pub *drvr, int ifidx, uint cmd,
25 void *buf, uint len); 23 void *buf, uint len);
26 int (*set_dcmd)(struct brcmf_pub *drvr, int ifidx, uint cmd, void *buf, 24 int (*set_dcmd)(struct brcmf_pub *drvr, int ifidx, uint cmd, void *buf,
27 uint len); 25 uint len);
26 int (*txdata)(struct brcmf_pub *drvr, int ifidx, u8 offset,
27 struct sk_buff *skb);
28 void *pd; 28 void *pd;
29}; 29};
30 30
@@ -32,11 +32,6 @@ struct brcmf_proto {
32int brcmf_proto_attach(struct brcmf_pub *drvr); 32int brcmf_proto_attach(struct brcmf_pub *drvr);
33void brcmf_proto_detach(struct brcmf_pub *drvr); 33void brcmf_proto_detach(struct brcmf_pub *drvr);
34 34
35static inline void brcmf_proto_hdrpush(struct brcmf_pub *drvr, int ifidx,
36 u8 offset, struct sk_buff *skb)
37{
38 drvr->proto->hdrpush(drvr, ifidx, offset, skb);
39}
40static inline int brcmf_proto_hdrpull(struct brcmf_pub *drvr, bool do_fws, 35static inline int brcmf_proto_hdrpull(struct brcmf_pub *drvr, bool do_fws,
41 u8 *ifidx, struct sk_buff *skb) 36 u8 *ifidx, struct sk_buff *skb)
42{ 37{
@@ -52,6 +47,11 @@ static inline int brcmf_proto_set_dcmd(struct brcmf_pub *drvr, int ifidx,
52{ 47{
53 return drvr->proto->set_dcmd(drvr, ifidx, cmd, buf, len); 48 return drvr->proto->set_dcmd(drvr, ifidx, cmd, buf, len);
54} 49}
50static inline int brcmf_proto_txdata(struct brcmf_pub *drvr, int ifidx,
51 u8 offset, struct sk_buff *skb)
52{
53 return drvr->proto->txdata(drvr, ifidx, offset, skb);
54}
55 55
56 56
57#endif /* BRCMFMAC_PROTO_H */ 57#endif /* BRCMFMAC_PROTO_H */
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/sdio_chip.c b/drivers/net/wireless/brcm80211/brcmfmac/sdio_chip.c
index 2096a14ef1fb..5f39f28e6efb 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/sdio_chip.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/sdio_chip.c
@@ -112,9 +112,9 @@ brcmf_sdio_sb_corerev(struct brcmf_sdio_dev *sdiodev,
112 112
113 idx = brcmf_sdio_chip_getinfidx(ci, coreid); 113 idx = brcmf_sdio_chip_getinfidx(ci, coreid);
114 114
115 regdata = brcmf_sdio_regrl(sdiodev, 115 regdata = brcmf_sdiod_regrl(sdiodev,
116 CORE_SB(ci->c_inf[idx].base, sbidhigh), 116 CORE_SB(ci->c_inf[idx].base, sbidhigh),
117 NULL); 117 NULL);
118 return SBCOREREV(regdata); 118 return SBCOREREV(regdata);
119} 119}
120 120
@@ -140,9 +140,9 @@ brcmf_sdio_sb_iscoreup(struct brcmf_sdio_dev *sdiodev,
140 if (idx == BRCMF_MAX_CORENUM) 140 if (idx == BRCMF_MAX_CORENUM)
141 return false; 141 return false;
142 142
143 regdata = brcmf_sdio_regrl(sdiodev, 143 regdata = brcmf_sdiod_regrl(sdiodev,
144 CORE_SB(ci->c_inf[idx].base, sbtmstatelow), 144 CORE_SB(ci->c_inf[idx].base, sbtmstatelow),
145 NULL); 145 NULL);
146 regdata &= (SSB_TMSLOW_RESET | SSB_TMSLOW_REJECT | 146 regdata &= (SSB_TMSLOW_RESET | SSB_TMSLOW_REJECT |
147 SSB_IMSTATE_REJECT | SSB_TMSLOW_CLOCK); 147 SSB_IMSTATE_REJECT | SSB_TMSLOW_CLOCK);
148 return (SSB_TMSLOW_CLOCK == regdata); 148 return (SSB_TMSLOW_CLOCK == regdata);
@@ -160,13 +160,13 @@ brcmf_sdio_ai_iscoreup(struct brcmf_sdio_dev *sdiodev,
160 if (idx == BRCMF_MAX_CORENUM) 160 if (idx == BRCMF_MAX_CORENUM)
161 return false; 161 return false;
162 162
163 regdata = brcmf_sdio_regrl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL, 163 regdata = brcmf_sdiod_regrl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL,
164 NULL); 164 NULL);
165 ret = (regdata & (BCMA_IOCTL_FGC | BCMA_IOCTL_CLK)) == BCMA_IOCTL_CLK; 165 ret = (regdata & (BCMA_IOCTL_FGC | BCMA_IOCTL_CLK)) == BCMA_IOCTL_CLK;
166 166
167 regdata = brcmf_sdio_regrl(sdiodev, 167 regdata = brcmf_sdiod_regrl(sdiodev,
168 ci->c_inf[idx].wrapbase+BCMA_RESET_CTL, 168 ci->c_inf[idx].wrapbase+BCMA_RESET_CTL,
169 NULL); 169 NULL);
170 ret = ret && ((regdata & BCMA_RESET_CTL_RESET) == 0); 170 ret = ret && ((regdata & BCMA_RESET_CTL_RESET) == 0);
171 171
172 return ret; 172 return ret;
@@ -182,79 +182,79 @@ brcmf_sdio_sb_coredisable(struct brcmf_sdio_dev *sdiodev,
182 idx = brcmf_sdio_chip_getinfidx(ci, coreid); 182 idx = brcmf_sdio_chip_getinfidx(ci, coreid);
183 base = ci->c_inf[idx].base; 183 base = ci->c_inf[idx].base;
184 184
185 regdata = brcmf_sdio_regrl(sdiodev, CORE_SB(base, sbtmstatelow), NULL); 185 regdata = brcmf_sdiod_regrl(sdiodev, CORE_SB(base, sbtmstatelow), NULL);
186 if (regdata & SSB_TMSLOW_RESET) 186 if (regdata & SSB_TMSLOW_RESET)
187 return; 187 return;
188 188
189 regdata = brcmf_sdio_regrl(sdiodev, CORE_SB(base, sbtmstatelow), NULL); 189 regdata = brcmf_sdiod_regrl(sdiodev, CORE_SB(base, sbtmstatelow), NULL);
190 if ((regdata & SSB_TMSLOW_CLOCK) != 0) { 190 if ((regdata & SSB_TMSLOW_CLOCK) != 0) {
191 /* 191 /*
192 * set target reject and spin until busy is clear 192 * set target reject and spin until busy is clear
193 * (preserve core-specific bits) 193 * (preserve core-specific bits)
194 */ 194 */
195 regdata = brcmf_sdio_regrl(sdiodev, CORE_SB(base, sbtmstatelow), 195 regdata = brcmf_sdiod_regrl(sdiodev,
196 NULL); 196 CORE_SB(base, sbtmstatelow), NULL);
197 brcmf_sdio_regwl(sdiodev, CORE_SB(base, sbtmstatelow), 197 brcmf_sdiod_regwl(sdiodev, CORE_SB(base, sbtmstatelow),
198 regdata | SSB_TMSLOW_REJECT, NULL); 198 regdata | SSB_TMSLOW_REJECT, NULL);
199 199
200 regdata = brcmf_sdio_regrl(sdiodev, CORE_SB(base, sbtmstatelow), 200 regdata = brcmf_sdiod_regrl(sdiodev,
201 NULL); 201 CORE_SB(base, sbtmstatelow), NULL);
202 udelay(1); 202 udelay(1);
203 SPINWAIT((brcmf_sdio_regrl(sdiodev, 203 SPINWAIT((brcmf_sdiod_regrl(sdiodev,
204 CORE_SB(base, sbtmstatehigh), 204 CORE_SB(base, sbtmstatehigh),
205 NULL) & 205 NULL) &
206 SSB_TMSHIGH_BUSY), 100000); 206 SSB_TMSHIGH_BUSY), 100000);
207 207
208 regdata = brcmf_sdio_regrl(sdiodev, 208 regdata = brcmf_sdiod_regrl(sdiodev,
209 CORE_SB(base, sbtmstatehigh), 209 CORE_SB(base, sbtmstatehigh),
210 NULL); 210 NULL);
211 if (regdata & SSB_TMSHIGH_BUSY) 211 if (regdata & SSB_TMSHIGH_BUSY)
212 brcmf_err("core state still busy\n"); 212 brcmf_err("core state still busy\n");
213 213
214 regdata = brcmf_sdio_regrl(sdiodev, CORE_SB(base, sbidlow), 214 regdata = brcmf_sdiod_regrl(sdiodev, CORE_SB(base, sbidlow),
215 NULL); 215 NULL);
216 if (regdata & SSB_IDLOW_INITIATOR) { 216 if (regdata & SSB_IDLOW_INITIATOR) {
217 regdata = brcmf_sdio_regrl(sdiodev, 217 regdata = brcmf_sdiod_regrl(sdiodev,
218 CORE_SB(base, sbimstate), 218 CORE_SB(base, sbimstate),
219 NULL); 219 NULL);
220 regdata |= SSB_IMSTATE_REJECT; 220 regdata |= SSB_IMSTATE_REJECT;
221 brcmf_sdio_regwl(sdiodev, CORE_SB(base, sbimstate), 221 brcmf_sdiod_regwl(sdiodev, CORE_SB(base, sbimstate),
222 regdata, NULL); 222 regdata, NULL);
223 regdata = brcmf_sdio_regrl(sdiodev, 223 regdata = brcmf_sdiod_regrl(sdiodev,
224 CORE_SB(base, sbimstate), 224 CORE_SB(base, sbimstate),
225 NULL); 225 NULL);
226 udelay(1); 226 udelay(1);
227 SPINWAIT((brcmf_sdio_regrl(sdiodev, 227 SPINWAIT((brcmf_sdiod_regrl(sdiodev,
228 CORE_SB(base, sbimstate), 228 CORE_SB(base, sbimstate),
229 NULL) & 229 NULL) &
230 SSB_IMSTATE_BUSY), 100000); 230 SSB_IMSTATE_BUSY), 100000);
231 } 231 }
232 232
233 /* set reset and reject while enabling the clocks */ 233 /* set reset and reject while enabling the clocks */
234 regdata = SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 234 regdata = SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK |
235 SSB_TMSLOW_REJECT | SSB_TMSLOW_RESET; 235 SSB_TMSLOW_REJECT | SSB_TMSLOW_RESET;
236 brcmf_sdio_regwl(sdiodev, CORE_SB(base, sbtmstatelow), 236 brcmf_sdiod_regwl(sdiodev, CORE_SB(base, sbtmstatelow),
237 regdata, NULL); 237 regdata, NULL);
238 regdata = brcmf_sdio_regrl(sdiodev, CORE_SB(base, sbtmstatelow), 238 regdata = brcmf_sdiod_regrl(sdiodev,
239 NULL); 239 CORE_SB(base, sbtmstatelow), NULL);
240 udelay(10); 240 udelay(10);
241 241
242 /* clear the initiator reject bit */ 242 /* clear the initiator reject bit */
243 regdata = brcmf_sdio_regrl(sdiodev, CORE_SB(base, sbidlow), 243 regdata = brcmf_sdiod_regrl(sdiodev, CORE_SB(base, sbidlow),
244 NULL); 244 NULL);
245 if (regdata & SSB_IDLOW_INITIATOR) { 245 if (regdata & SSB_IDLOW_INITIATOR) {
246 regdata = brcmf_sdio_regrl(sdiodev, 246 regdata = brcmf_sdiod_regrl(sdiodev,
247 CORE_SB(base, sbimstate), 247 CORE_SB(base, sbimstate),
248 NULL); 248 NULL);
249 regdata &= ~SSB_IMSTATE_REJECT; 249 regdata &= ~SSB_IMSTATE_REJECT;
250 brcmf_sdio_regwl(sdiodev, CORE_SB(base, sbimstate), 250 brcmf_sdiod_regwl(sdiodev, CORE_SB(base, sbimstate),
251 regdata, NULL); 251 regdata, NULL);
252 } 252 }
253 } 253 }
254 254
255 /* leave reset and reject asserted */ 255 /* leave reset and reject asserted */
256 brcmf_sdio_regwl(sdiodev, CORE_SB(base, sbtmstatelow), 256 brcmf_sdiod_regwl(sdiodev, CORE_SB(base, sbtmstatelow),
257 (SSB_TMSLOW_REJECT | SSB_TMSLOW_RESET), NULL); 257 (SSB_TMSLOW_REJECT | SSB_TMSLOW_RESET), NULL);
258 udelay(1); 258 udelay(1);
259} 259}
260 260
@@ -270,9 +270,9 @@ brcmf_sdio_ai_coredisable(struct brcmf_sdio_dev *sdiodev,
270 return; 270 return;
271 271
272 /* if core is already in reset, just return */ 272 /* if core is already in reset, just return */
273 regdata = brcmf_sdio_regrl(sdiodev, 273 regdata = brcmf_sdiod_regrl(sdiodev,
274 ci->c_inf[idx].wrapbase+BCMA_RESET_CTL, 274 ci->c_inf[idx].wrapbase+BCMA_RESET_CTL,
275 NULL); 275 NULL);
276 if ((regdata & BCMA_RESET_CTL_RESET) != 0) 276 if ((regdata & BCMA_RESET_CTL_RESET) != 0)
277 return; 277 return;
278 278
@@ -281,24 +281,24 @@ brcmf_sdio_ai_coredisable(struct brcmf_sdio_dev *sdiodev,
281 * extra 10ms is taken into account for firmware load stage 281 * extra 10ms is taken into account for firmware load stage
282 * after 10300us carry on disabling the core anyway 282 * after 10300us carry on disabling the core anyway
283 */ 283 */
284 SPINWAIT(brcmf_sdio_regrl(sdiodev, 284 SPINWAIT(brcmf_sdiod_regrl(sdiodev,
285 ci->c_inf[idx].wrapbase+BCMA_RESET_ST,
286 NULL), 10300);
287 regdata = brcmf_sdio_regrl(sdiodev,
288 ci->c_inf[idx].wrapbase+BCMA_RESET_ST, 285 ci->c_inf[idx].wrapbase+BCMA_RESET_ST,
289 NULL); 286 NULL), 10300);
287 regdata = brcmf_sdiod_regrl(sdiodev,
288 ci->c_inf[idx].wrapbase+BCMA_RESET_ST,
289 NULL);
290 if (regdata) 290 if (regdata)
291 brcmf_err("disabling core 0x%x with reset status %x\n", 291 brcmf_err("disabling core 0x%x with reset status %x\n",
292 coreid, regdata); 292 coreid, regdata);
293 293
294 brcmf_sdio_regwl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_RESET_CTL, 294 brcmf_sdiod_regwl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_RESET_CTL,
295 BCMA_RESET_CTL_RESET, NULL); 295 BCMA_RESET_CTL_RESET, NULL);
296 udelay(1); 296 udelay(1);
297 297
298 brcmf_sdio_regwl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL, 298 brcmf_sdiod_regwl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL,
299 core_bits, NULL); 299 core_bits, NULL);
300 regdata = brcmf_sdio_regrl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL, 300 regdata = brcmf_sdiod_regrl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL,
301 NULL); 301 NULL);
302 usleep_range(10, 20); 302 usleep_range(10, 20);
303 303
304} 304}
@@ -325,47 +325,47 @@ brcmf_sdio_sb_resetcore(struct brcmf_sdio_dev *sdiodev,
325 * set reset while enabling the clock and 325 * set reset while enabling the clock and
326 * forcing them on throughout the core 326 * forcing them on throughout the core
327 */ 327 */
328 brcmf_sdio_regwl(sdiodev, 328 brcmf_sdiod_regwl(sdiodev,
329 CORE_SB(ci->c_inf[idx].base, sbtmstatelow), 329 CORE_SB(ci->c_inf[idx].base, sbtmstatelow),
330 SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | SSB_TMSLOW_RESET, 330 SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | SSB_TMSLOW_RESET,
331 NULL); 331 NULL);
332 regdata = brcmf_sdio_regrl(sdiodev, 332 regdata = brcmf_sdiod_regrl(sdiodev,
333 CORE_SB(ci->c_inf[idx].base, sbtmstatelow), 333 CORE_SB(ci->c_inf[idx].base, sbtmstatelow),
334 NULL); 334 NULL);
335 udelay(1); 335 udelay(1);
336 336
337 /* clear any serror */ 337 /* clear any serror */
338 regdata = brcmf_sdio_regrl(sdiodev, 338 regdata = brcmf_sdiod_regrl(sdiodev,
339 CORE_SB(ci->c_inf[idx].base, sbtmstatehigh), 339 CORE_SB(ci->c_inf[idx].base, sbtmstatehigh),
340 NULL); 340 NULL);
341 if (regdata & SSB_TMSHIGH_SERR) 341 if (regdata & SSB_TMSHIGH_SERR)
342 brcmf_sdio_regwl(sdiodev, 342 brcmf_sdiod_regwl(sdiodev,
343 CORE_SB(ci->c_inf[idx].base, sbtmstatehigh), 343 CORE_SB(ci->c_inf[idx].base, sbtmstatehigh),
344 0, NULL); 344 0, NULL);
345 345
346 regdata = brcmf_sdio_regrl(sdiodev, 346 regdata = brcmf_sdiod_regrl(sdiodev,
347 CORE_SB(ci->c_inf[idx].base, sbimstate), 347 CORE_SB(ci->c_inf[idx].base, sbimstate),
348 NULL); 348 NULL);
349 if (regdata & (SSB_IMSTATE_IBE | SSB_IMSTATE_TO)) 349 if (regdata & (SSB_IMSTATE_IBE | SSB_IMSTATE_TO))
350 brcmf_sdio_regwl(sdiodev, 350 brcmf_sdiod_regwl(sdiodev,
351 CORE_SB(ci->c_inf[idx].base, sbimstate), 351 CORE_SB(ci->c_inf[idx].base, sbimstate),
352 regdata & ~(SSB_IMSTATE_IBE | SSB_IMSTATE_TO), 352 regdata & ~(SSB_IMSTATE_IBE | SSB_IMSTATE_TO),
353 NULL); 353 NULL);
354 354
355 /* clear reset and allow it to propagate throughout the core */ 355 /* clear reset and allow it to propagate throughout the core */
356 brcmf_sdio_regwl(sdiodev, CORE_SB(ci->c_inf[idx].base, sbtmstatelow), 356 brcmf_sdiod_regwl(sdiodev, CORE_SB(ci->c_inf[idx].base, sbtmstatelow),
357 SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK, NULL); 357 SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK, NULL);
358 regdata = brcmf_sdio_regrl(sdiodev, 358 regdata = brcmf_sdiod_regrl(sdiodev,
359 CORE_SB(ci->c_inf[idx].base, sbtmstatelow), 359 CORE_SB(ci->c_inf[idx].base, sbtmstatelow),
360 NULL); 360 NULL);
361 udelay(1); 361 udelay(1);
362 362
363 /* leave clock enabled */ 363 /* leave clock enabled */
364 brcmf_sdio_regwl(sdiodev, CORE_SB(ci->c_inf[idx].base, sbtmstatelow), 364 brcmf_sdiod_regwl(sdiodev, CORE_SB(ci->c_inf[idx].base, sbtmstatelow),
365 SSB_TMSLOW_CLOCK, NULL); 365 SSB_TMSLOW_CLOCK, NULL);
366 regdata = brcmf_sdio_regrl(sdiodev, 366 regdata = brcmf_sdiod_regrl(sdiodev,
367 CORE_SB(ci->c_inf[idx].base, sbtmstatelow), 367 CORE_SB(ci->c_inf[idx].base, sbtmstatelow),
368 NULL); 368 NULL);
369 udelay(1); 369 udelay(1);
370} 370}
371 371
@@ -384,21 +384,21 @@ brcmf_sdio_ai_resetcore(struct brcmf_sdio_dev *sdiodev,
384 brcmf_sdio_ai_coredisable(sdiodev, ci, coreid, core_bits); 384 brcmf_sdio_ai_coredisable(sdiodev, ci, coreid, core_bits);
385 385
386 /* now do initialization sequence */ 386 /* now do initialization sequence */
387 brcmf_sdio_regwl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL, 387 brcmf_sdiod_regwl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL,
388 core_bits | BCMA_IOCTL_FGC | BCMA_IOCTL_CLK, NULL); 388 core_bits | BCMA_IOCTL_FGC | BCMA_IOCTL_CLK, NULL);
389 regdata = brcmf_sdio_regrl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL, 389 regdata = brcmf_sdiod_regrl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL,
390 NULL); 390 NULL);
391 brcmf_sdio_regwl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_RESET_CTL, 391 brcmf_sdiod_regwl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_RESET_CTL,
392 0, NULL); 392 0, NULL);
393 regdata = brcmf_sdio_regrl(sdiodev, 393 regdata = brcmf_sdiod_regrl(sdiodev,
394 ci->c_inf[idx].wrapbase+BCMA_RESET_CTL, 394 ci->c_inf[idx].wrapbase+BCMA_RESET_CTL,
395 NULL); 395 NULL);
396 udelay(1); 396 udelay(1);
397 397
398 brcmf_sdio_regwl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL, 398 brcmf_sdiod_regwl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL,
399 core_bits | BCMA_IOCTL_CLK, NULL); 399 core_bits | BCMA_IOCTL_CLK, NULL);
400 regdata = brcmf_sdio_regrl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL, 400 regdata = brcmf_sdiod_regrl(sdiodev, ci->c_inf[idx].wrapbase+BCMA_IOCTL,
401 NULL); 401 NULL);
402 udelay(1); 402 udelay(1);
403} 403}
404 404
@@ -438,7 +438,7 @@ static inline int brcmf_sdio_chip_cichk(struct chip_info *ci)
438#endif 438#endif
439 439
440static int brcmf_sdio_chip_recognition(struct brcmf_sdio_dev *sdiodev, 440static int brcmf_sdio_chip_recognition(struct brcmf_sdio_dev *sdiodev,
441 struct chip_info *ci, u32 regs) 441 struct chip_info *ci)
442{ 442{
443 u32 regdata; 443 u32 regdata;
444 int ret; 444 int ret;
@@ -449,10 +449,10 @@ static int brcmf_sdio_chip_recognition(struct brcmf_sdio_dev *sdiodev,
449 * other ways of recognition should be added here. 449 * other ways of recognition should be added here.
450 */ 450 */
451 ci->c_inf[0].id = BCMA_CORE_CHIPCOMMON; 451 ci->c_inf[0].id = BCMA_CORE_CHIPCOMMON;
452 ci->c_inf[0].base = regs; 452 ci->c_inf[0].base = SI_ENUM_BASE;
453 regdata = brcmf_sdio_regrl(sdiodev, 453 regdata = brcmf_sdiod_regrl(sdiodev,
454 CORE_CC_REG(ci->c_inf[0].base, chipid), 454 CORE_CC_REG(ci->c_inf[0].base, chipid),
455 NULL); 455 NULL);
456 ci->chip = regdata & CID_ID_MASK; 456 ci->chip = regdata & CID_ID_MASK;
457 ci->chiprev = (regdata & CID_REV_MASK) >> CID_REV_SHIFT; 457 ci->chiprev = (regdata & CID_REV_MASK) >> CID_REV_SHIFT;
458 if (sdiodev->func[0]->device == SDIO_DEVICE_ID_BROADCOM_4335_4339 && 458 if (sdiodev->func[0]->device == SDIO_DEVICE_ID_BROADCOM_4335_4339 &&
@@ -607,7 +607,7 @@ brcmf_sdio_chip_buscoreprep(struct brcmf_sdio_dev *sdiodev)
607 607
608 /* Try forcing SDIO core to do ALPAvail request only */ 608 /* Try forcing SDIO core to do ALPAvail request only */
609 clkset = SBSDIO_FORCE_HW_CLKREQ_OFF | SBSDIO_ALP_AVAIL_REQ; 609 clkset = SBSDIO_FORCE_HW_CLKREQ_OFF | SBSDIO_ALP_AVAIL_REQ;
610 brcmf_sdio_regwb(sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, clkset, &err); 610 brcmf_sdiod_regwb(sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, clkset, &err);
611 if (err) { 611 if (err) {
612 brcmf_err("error writing for HT off\n"); 612 brcmf_err("error writing for HT off\n");
613 return err; 613 return err;
@@ -615,8 +615,8 @@ brcmf_sdio_chip_buscoreprep(struct brcmf_sdio_dev *sdiodev)
615 615
616 /* If register supported, wait for ALPAvail and then force ALP */ 616 /* If register supported, wait for ALPAvail and then force ALP */
617 /* This may take up to 15 milliseconds */ 617 /* This may take up to 15 milliseconds */
618 clkval = brcmf_sdio_regrb(sdiodev, 618 clkval = brcmf_sdiod_regrb(sdiodev,
619 SBSDIO_FUNC1_CHIPCLKCSR, NULL); 619 SBSDIO_FUNC1_CHIPCLKCSR, NULL);
620 620
621 if ((clkval & ~SBSDIO_AVBITS) != clkset) { 621 if ((clkval & ~SBSDIO_AVBITS) != clkset) {
622 brcmf_err("ChipClkCSR access: wrote 0x%02x read 0x%02x\n", 622 brcmf_err("ChipClkCSR access: wrote 0x%02x read 0x%02x\n",
@@ -624,8 +624,8 @@ brcmf_sdio_chip_buscoreprep(struct brcmf_sdio_dev *sdiodev)
624 return -EACCES; 624 return -EACCES;
625 } 625 }
626 626
627 SPINWAIT(((clkval = brcmf_sdio_regrb(sdiodev, 627 SPINWAIT(((clkval = brcmf_sdiod_regrb(sdiodev,
628 SBSDIO_FUNC1_CHIPCLKCSR, NULL)), 628 SBSDIO_FUNC1_CHIPCLKCSR, NULL)),
629 !SBSDIO_ALPAV(clkval)), 629 !SBSDIO_ALPAV(clkval)),
630 PMU_MAX_TRANSITION_DLY); 630 PMU_MAX_TRANSITION_DLY);
631 if (!SBSDIO_ALPAV(clkval)) { 631 if (!SBSDIO_ALPAV(clkval)) {
@@ -635,11 +635,11 @@ brcmf_sdio_chip_buscoreprep(struct brcmf_sdio_dev *sdiodev)
635 } 635 }
636 636
637 clkset = SBSDIO_FORCE_HW_CLKREQ_OFF | SBSDIO_FORCE_ALP; 637 clkset = SBSDIO_FORCE_HW_CLKREQ_OFF | SBSDIO_FORCE_ALP;
638 brcmf_sdio_regwb(sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, clkset, &err); 638 brcmf_sdiod_regwb(sdiodev, SBSDIO_FUNC1_CHIPCLKCSR, clkset, &err);
639 udelay(65); 639 udelay(65);
640 640
641 /* Also, disable the extra SDIO pull-ups */ 641 /* Also, disable the extra SDIO pull-ups */
642 brcmf_sdio_regwb(sdiodev, SBSDIO_FUNC1_SDIOPULLUP, 0, NULL); 642 brcmf_sdiod_regwb(sdiodev, SBSDIO_FUNC1_SDIOPULLUP, 0, NULL);
643 643
644 return 0; 644 return 0;
645} 645}
@@ -654,16 +654,16 @@ brcmf_sdio_chip_buscoresetup(struct brcmf_sdio_dev *sdiodev,
654 ci->c_inf[0].rev = ci->corerev(sdiodev, ci, ci->c_inf[0].id); 654 ci->c_inf[0].rev = ci->corerev(sdiodev, ci, ci->c_inf[0].id);
655 655
656 /* get chipcommon capabilites */ 656 /* get chipcommon capabilites */
657 ci->c_inf[0].caps = brcmf_sdio_regrl(sdiodev, 657 ci->c_inf[0].caps = brcmf_sdiod_regrl(sdiodev,
658 CORE_CC_REG(base, capabilities), 658 CORE_CC_REG(base, capabilities),
659 NULL); 659 NULL);
660 660
661 /* get pmu caps & rev */ 661 /* get pmu caps & rev */
662 if (ci->c_inf[0].caps & CC_CAP_PMU) { 662 if (ci->c_inf[0].caps & CC_CAP_PMU) {
663 ci->pmucaps = 663 ci->pmucaps =
664 brcmf_sdio_regrl(sdiodev, 664 brcmf_sdiod_regrl(sdiodev,
665 CORE_CC_REG(base, pmucapabilities), 665 CORE_CC_REG(base, pmucapabilities),
666 NULL); 666 NULL);
667 ci->pmurev = ci->pmucaps & PCAP_REV_MASK; 667 ci->pmurev = ci->pmucaps & PCAP_REV_MASK;
668 } 668 }
669 669
@@ -681,7 +681,7 @@ brcmf_sdio_chip_buscoresetup(struct brcmf_sdio_dev *sdiodev,
681} 681}
682 682
683int brcmf_sdio_chip_attach(struct brcmf_sdio_dev *sdiodev, 683int brcmf_sdio_chip_attach(struct brcmf_sdio_dev *sdiodev,
684 struct chip_info **ci_ptr, u32 regs) 684 struct chip_info **ci_ptr)
685{ 685{
686 int ret; 686 int ret;
687 struct chip_info *ci; 687 struct chip_info *ci;
@@ -697,16 +697,16 @@ int brcmf_sdio_chip_attach(struct brcmf_sdio_dev *sdiodev,
697 if (ret != 0) 697 if (ret != 0)
698 goto err; 698 goto err;
699 699
700 ret = brcmf_sdio_chip_recognition(sdiodev, ci, regs); 700 ret = brcmf_sdio_chip_recognition(sdiodev, ci);
701 if (ret != 0) 701 if (ret != 0)
702 goto err; 702 goto err;
703 703
704 brcmf_sdio_chip_buscoresetup(sdiodev, ci); 704 brcmf_sdio_chip_buscoresetup(sdiodev, ci);
705 705
706 brcmf_sdio_regwl(sdiodev, CORE_CC_REG(ci->c_inf[0].base, gpiopullup), 706 brcmf_sdiod_regwl(sdiodev, CORE_CC_REG(ci->c_inf[0].base, gpiopullup),
707 0, NULL); 707 0, NULL);
708 brcmf_sdio_regwl(sdiodev, CORE_CC_REG(ci->c_inf[0].base, gpiopulldown), 708 brcmf_sdiod_regwl(sdiodev, CORE_CC_REG(ci->c_inf[0].base, gpiopulldown),
709 0, NULL); 709 0, NULL);
710 710
711 *ci_ptr = ci; 711 *ci_ptr = ci;
712 return 0; 712 return 0;
@@ -784,12 +784,12 @@ brcmf_sdio_chip_drivestrengthinit(struct brcmf_sdio_dev *sdiodev,
784 } 784 }
785 } 785 }
786 addr = CORE_CC_REG(base, chipcontrol_addr); 786 addr = CORE_CC_REG(base, chipcontrol_addr);
787 brcmf_sdio_regwl(sdiodev, addr, 1, NULL); 787 brcmf_sdiod_regwl(sdiodev, addr, 1, NULL);
788 cc_data_temp = brcmf_sdio_regrl(sdiodev, addr, NULL); 788 cc_data_temp = brcmf_sdiod_regrl(sdiodev, addr, NULL);
789 cc_data_temp &= ~str_mask; 789 cc_data_temp &= ~str_mask;
790 drivestrength_sel <<= str_shift; 790 drivestrength_sel <<= str_shift;
791 cc_data_temp |= drivestrength_sel; 791 cc_data_temp |= drivestrength_sel;
792 brcmf_sdio_regwl(sdiodev, addr, cc_data_temp, NULL); 792 brcmf_sdiod_regwl(sdiodev, addr, cc_data_temp, NULL);
793 793
794 brcmf_dbg(INFO, "SDIO: %d mA (req=%d mA) drive strength selected, set to 0x%08x\n", 794 brcmf_dbg(INFO, "SDIO: %d mA (req=%d mA) drive strength selected, set to 0x%08x\n",
795 str_tab[i].strength, drivestrength, cc_data_temp); 795 str_tab[i].strength, drivestrength, cc_data_temp);
@@ -816,8 +816,8 @@ brcmf_sdio_chip_verifynvram(struct brcmf_sdio_dev *sdiodev, u32 nvram_addr,
816 memset(nvram_ularray, 0xaa, nvram_sz); 816 memset(nvram_ularray, 0xaa, nvram_sz);
817 817
818 /* Read the vars list to temp buffer for comparison */ 818 /* Read the vars list to temp buffer for comparison */
819 err = brcmf_sdio_ramrw(sdiodev, false, nvram_addr, nvram_ularray, 819 err = brcmf_sdiod_ramrw(sdiodev, false, nvram_addr, nvram_ularray,
820 nvram_sz); 820 nvram_sz);
821 if (err) { 821 if (err) {
822 brcmf_err("error %d on reading %d nvram bytes at 0x%08x\n", 822 brcmf_err("error %d on reading %d nvram bytes at 0x%08x\n",
823 err, nvram_sz, nvram_addr); 823 err, nvram_sz, nvram_addr);
@@ -850,7 +850,7 @@ static bool brcmf_sdio_chip_writenvram(struct brcmf_sdio_dev *sdiodev,
850 nvram_addr = (ci->ramsize - 4) - nvram_sz + ci->rambase; 850 nvram_addr = (ci->ramsize - 4) - nvram_sz + ci->rambase;
851 851
852 /* Write the vars list */ 852 /* Write the vars list */
853 err = brcmf_sdio_ramrw(sdiodev, true, nvram_addr, nvram_dat, nvram_sz); 853 err = brcmf_sdiod_ramrw(sdiodev, true, nvram_addr, nvram_dat, nvram_sz);
854 if (err) { 854 if (err) {
855 brcmf_err("error %d on writing %d nvram bytes at 0x%08x\n", 855 brcmf_err("error %d on writing %d nvram bytes at 0x%08x\n",
856 err, nvram_sz, nvram_addr); 856 err, nvram_sz, nvram_addr);
@@ -874,8 +874,8 @@ static bool brcmf_sdio_chip_writenvram(struct brcmf_sdio_dev *sdiodev,
874 nvram_addr, nvram_sz, token); 874 nvram_addr, nvram_sz, token);
875 875
876 /* Write the length token to the last word */ 876 /* Write the length token to the last word */
877 if (brcmf_sdio_ramrw(sdiodev, true, (ci->ramsize - 4 + ci->rambase), 877 if (brcmf_sdiod_ramrw(sdiodev, true, (ci->ramsize - 4 + ci->rambase),
878 (u8 *)&token_le, 4)) 878 (u8 *)&token_le, 4))
879 return false; 879 return false;
880 880
881 return true; 881 return true;
@@ -891,7 +891,7 @@ brcmf_sdio_chip_cm3_enterdl(struct brcmf_sdio_dev *sdiodev,
891 ci->resetcore(sdiodev, ci, BCMA_CORE_INTERNAL_MEM, 0); 891 ci->resetcore(sdiodev, ci, BCMA_CORE_INTERNAL_MEM, 0);
892 892
893 /* clear length token */ 893 /* clear length token */
894 brcmf_sdio_ramrw(sdiodev, true, ci->ramsize - 4, (u8 *)&zeros, 4); 894 brcmf_sdiod_ramrw(sdiodev, true, ci->ramsize - 4, (u8 *)&zeros, 4);
895} 895}
896 896
897static bool 897static bool
@@ -913,7 +913,7 @@ brcmf_sdio_chip_cm3_exitdl(struct brcmf_sdio_dev *sdiodev, struct chip_info *ci,
913 core_idx = brcmf_sdio_chip_getinfidx(ci, BCMA_CORE_SDIO_DEV); 913 core_idx = brcmf_sdio_chip_getinfidx(ci, BCMA_CORE_SDIO_DEV);
914 reg_addr = ci->c_inf[core_idx].base; 914 reg_addr = ci->c_inf[core_idx].base;
915 reg_addr += offsetof(struct sdpcmd_regs, intstatus); 915 reg_addr += offsetof(struct sdpcmd_regs, intstatus);
916 brcmf_sdio_regwl(sdiodev, reg_addr, 0xFFFFFFFF, NULL); 916 brcmf_sdiod_regwl(sdiodev, reg_addr, 0xFFFFFFFF, NULL);
917 917
918 ci->resetcore(sdiodev, ci, BCMA_CORE_ARM_CM3, 0); 918 ci->resetcore(sdiodev, ci, BCMA_CORE_ARM_CM3, 0);
919 919
@@ -942,11 +942,11 @@ brcmf_sdio_chip_cr4_exitdl(struct brcmf_sdio_dev *sdiodev, struct chip_info *ci,
942 core_idx = brcmf_sdio_chip_getinfidx(ci, BCMA_CORE_SDIO_DEV); 942 core_idx = brcmf_sdio_chip_getinfidx(ci, BCMA_CORE_SDIO_DEV);
943 reg_addr = ci->c_inf[core_idx].base; 943 reg_addr = ci->c_inf[core_idx].base;
944 reg_addr += offsetof(struct sdpcmd_regs, intstatus); 944 reg_addr += offsetof(struct sdpcmd_regs, intstatus);
945 brcmf_sdio_regwl(sdiodev, reg_addr, 0xFFFFFFFF, NULL); 945 brcmf_sdiod_regwl(sdiodev, reg_addr, 0xFFFFFFFF, NULL);
946 946
947 /* Write reset vector to address 0 */ 947 /* Write reset vector to address 0 */
948 brcmf_sdio_ramrw(sdiodev, true, 0, (void *)&ci->rst_vec, 948 brcmf_sdiod_ramrw(sdiodev, true, 0, (void *)&ci->rst_vec,
949 sizeof(ci->rst_vec)); 949 sizeof(ci->rst_vec));
950 950
951 /* restore ARM */ 951 /* restore ARM */
952 ci->resetcore(sdiodev, ci, BCMA_CORE_ARM_CR4, 0); 952 ci->resetcore(sdiodev, ci, BCMA_CORE_ARM_CR4, 0);
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/sdio_chip.h b/drivers/net/wireless/brcm80211/brcmfmac/sdio_chip.h
index 507c61c991fa..d0f4b45b24c7 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/sdio_chip.h
+++ b/drivers/net/wireless/brcm80211/brcmfmac/sdio_chip.h
@@ -224,7 +224,7 @@ struct sdpcmd_regs {
224}; 224};
225 225
226int brcmf_sdio_chip_attach(struct brcmf_sdio_dev *sdiodev, 226int brcmf_sdio_chip_attach(struct brcmf_sdio_dev *sdiodev,
227 struct chip_info **ci_ptr, u32 regs); 227 struct chip_info **ci_ptr);
228void brcmf_sdio_chip_detach(struct chip_info **ci_ptr); 228void brcmf_sdio_chip_detach(struct chip_info **ci_ptr);
229void brcmf_sdio_chip_drivestrengthinit(struct brcmf_sdio_dev *sdiodev, 229void brcmf_sdio_chip_drivestrengthinit(struct brcmf_sdio_dev *sdiodev,
230 struct chip_info *ci, u32 drivestrength); 230 struct chip_info *ci, u32 drivestrength);
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/sdio_host.h b/drivers/net/wireless/brcm80211/brcmfmac/sdio_host.h
index fc0d4f0129db..a0981b32c729 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/sdio_host.h
+++ b/drivers/net/wireless/brcm80211/brcmfmac/sdio_host.h
@@ -164,9 +164,8 @@ struct brcmf_sdio;
164struct brcmf_sdio_dev { 164struct brcmf_sdio_dev {
165 struct sdio_func *func[SDIO_MAX_FUNCS]; 165 struct sdio_func *func[SDIO_MAX_FUNCS];
166 u8 num_funcs; /* Supported funcs on client */ 166 u8 num_funcs; /* Supported funcs on client */
167 u32 func_cis_ptr[SDIOD_MAX_IOFUNCS];
168 u32 sbwad; /* Save backplane window address */ 167 u32 sbwad; /* Save backplane window address */
169 void *bus; 168 struct brcmf_sdio *bus;
170 atomic_t suspend; /* suspend flag */ 169 atomic_t suspend; /* suspend flag */
171 wait_queue_head_t request_byte_wait; 170 wait_queue_head_t request_byte_wait;
172 wait_queue_head_t request_word_wait; 171 wait_queue_head_t request_word_wait;
@@ -185,22 +184,19 @@ struct brcmf_sdio_dev {
185}; 184};
186 185
187/* Register/deregister interrupt handler. */ 186/* Register/deregister interrupt handler. */
188int brcmf_sdio_intr_register(struct brcmf_sdio_dev *sdiodev); 187int brcmf_sdiod_intr_register(struct brcmf_sdio_dev *sdiodev);
189int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev *sdiodev); 188int brcmf_sdiod_intr_unregister(struct brcmf_sdio_dev *sdiodev);
190 189
191/* sdio device register access interface */ 190/* sdio device register access interface */
192u8 brcmf_sdio_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret); 191u8 brcmf_sdiod_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret);
193u32 brcmf_sdio_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret); 192u32 brcmf_sdiod_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret);
194void brcmf_sdio_regwb(struct brcmf_sdio_dev *sdiodev, u32 addr, u8 data, 193void brcmf_sdiod_regwb(struct brcmf_sdio_dev *sdiodev, u32 addr, u8 data,
195 int *ret); 194 int *ret);
196void brcmf_sdio_regwl(struct brcmf_sdio_dev *sdiodev, u32 addr, u32 data, 195void brcmf_sdiod_regwl(struct brcmf_sdio_dev *sdiodev, u32 addr, u32 data,
197 int *ret); 196 int *ret);
198int brcmf_sdio_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
199 void *data, bool write);
200 197
201/* Buffer transfer to/from device (client) core via cmd53. 198/* Buffer transfer to/from device (client) core via cmd53.
202 * fn: function number 199 * fn: function number
203 * addr: backplane address (i.e. >= regsva from attach)
204 * flags: backplane width, address increment, sync/async 200 * flags: backplane width, address increment, sync/async
205 * buf: pointer to memory data buffer 201 * buf: pointer to memory data buffer
206 * nbytes: number of bytes to transfer to/from buf 202 * nbytes: number of bytes to transfer to/from buf
@@ -210,17 +206,14 @@ int brcmf_sdio_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
210 * Returns 0 or error code. 206 * Returns 0 or error code.
211 * NOTE: Async operation is not currently supported. 207 * NOTE: Async operation is not currently supported.
212 */ 208 */
213int brcmf_sdcard_send_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn, 209int brcmf_sdiod_send_pkt(struct brcmf_sdio_dev *sdiodev,
214 uint flags, struct sk_buff_head *pktq); 210 struct sk_buff_head *pktq);
215int brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn, 211int brcmf_sdiod_send_buf(struct brcmf_sdio_dev *sdiodev, u8 *buf, uint nbytes);
216 uint flags, u8 *buf, uint nbytes); 212
217 213int brcmf_sdiod_recv_pkt(struct brcmf_sdio_dev *sdiodev, struct sk_buff *pkt);
218int brcmf_sdcard_recv_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn, 214int brcmf_sdiod_recv_buf(struct brcmf_sdio_dev *sdiodev, u8 *buf, uint nbytes);
219 uint flags, struct sk_buff *pkt); 215int brcmf_sdiod_recv_chain(struct brcmf_sdio_dev *sdiodev,
220int brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn, 216 struct sk_buff_head *pktq, uint totlen);
221 uint flags, u8 *buf, uint nbytes);
222int brcmf_sdcard_recv_chain(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
223 uint flags, struct sk_buff_head *pktq, uint totlen);
224 217
225/* Flags bits */ 218/* Flags bits */
226 219
@@ -236,43 +229,16 @@ int brcmf_sdcard_recv_chain(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
236 * nbytes: number of bytes to transfer to/from buf 229 * nbytes: number of bytes to transfer to/from buf
237 * Returns 0 or error code. 230 * Returns 0 or error code.
238 */ 231 */
239int brcmf_sdcard_rwdata(struct brcmf_sdio_dev *sdiodev, uint rw, u32 addr, 232int brcmf_sdiod_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
240 u8 *buf, uint nbytes); 233 u8 *data, uint size);
241int brcmf_sdio_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
242 u8 *data, uint size);
243 234
244/* Issue an abort to the specified function */ 235/* Issue an abort to the specified function */
245int brcmf_sdcard_abort(struct brcmf_sdio_dev *sdiodev, uint fn); 236int brcmf_sdiod_abort(struct brcmf_sdio_dev *sdiodev, uint fn);
246
247/* platform specific/high level functions */
248int brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev);
249int brcmf_sdio_remove(struct brcmf_sdio_dev *sdiodev);
250
251/* attach, return handler on success, NULL if failed.
252 * The handler shall be provided by all subsequent calls. No local cache
253 * cfghdl points to the starting address of pci device mapped memory
254 */
255int brcmf_sdioh_attach(struct brcmf_sdio_dev *sdiodev);
256void brcmf_sdioh_detach(struct brcmf_sdio_dev *sdiodev);
257
258/* read or write one byte using cmd52 */
259int brcmf_sdioh_request_byte(struct brcmf_sdio_dev *sdiodev, uint rw, uint fnc,
260 uint addr, u8 *byte);
261
262/* read or write 2/4 bytes using cmd53 */
263int brcmf_sdioh_request_word(struct brcmf_sdio_dev *sdiodev, uint rw, uint fnc,
264 uint addr, u32 *word, uint nbyte);
265
266/* Watchdog timer interface for pm ops */
267void brcmf_sdio_wdtmr_enable(struct brcmf_sdio_dev *sdiodev, bool enable);
268 237
269void *brcmf_sdbrcm_probe(u32 regsva, struct brcmf_sdio_dev *sdiodev); 238struct brcmf_sdio *brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev);
270void brcmf_sdbrcm_disconnect(void *ptr); 239void brcmf_sdio_remove(struct brcmf_sdio *bus);
271void brcmf_sdbrcm_isr(void *arg); 240void brcmf_sdio_isr(struct brcmf_sdio *bus);
272 241
273void brcmf_sdbrcm_wd_timer(struct brcmf_sdio *bus, uint wdtick); 242void brcmf_sdio_wd_timer(struct brcmf_sdio *bus, uint wdtick);
274 243
275void brcmf_pm_resume_wait(struct brcmf_sdio_dev *sdiodev,
276 wait_queue_head_t *wq);
277bool brcmf_pm_resume_error(struct brcmf_sdio_dev *sdiodev);
278#endif /* _BRCM_SDH_H_ */ 244#endif /* _BRCM_SDH_H_ */
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/usb.c b/drivers/net/wireless/brcm80211/brcmfmac/usb.c
index 51c4de054b15..c345c32eb631 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/usb.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/usb.c
@@ -1253,6 +1253,7 @@ static int brcmf_usb_probe_cb(struct brcmf_usbdev_info *devinfo)
1253 bus->ops = &brcmf_usb_bus_ops; 1253 bus->ops = &brcmf_usb_bus_ops;
1254 bus->chip = bus_pub->devid; 1254 bus->chip = bus_pub->devid;
1255 bus->chiprev = bus_pub->chiprev; 1255 bus->chiprev = bus_pub->chiprev;
1256 bus->proto_type = BRCMF_PROTO_BCDC;
1256 1257
1257 /* Attach to the common driver interface */ 1258 /* Attach to the common driver interface */
1258 ret = brcmf_attach(dev); 1259 ret = brcmf_attach(dev);
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-23 02:04:54 -0500