Commit | Line | Data |
---|---|---|
5b435de0 AS |
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 | */ | |
02f77195 | 16 | |
5b435de0 AS |
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/suspend.h> | |
25 | #include <linux/errno.h> | |
26 | #include <linux/sched.h> /* request_irq() */ | |
b7a57e76 | 27 | #include <linux/module.h> |
ba89bf19 | 28 | #include <linux/platform_device.h> |
668761ac | 29 | #include <linux/platform_data/brcmfmac-sdio.h> |
5b435de0 AS |
30 | #include <net/cfg80211.h> |
31 | ||
32 | #include <defs.h> | |
33 | #include <brcm_hw_ids.h> | |
34 | #include <brcmu_utils.h> | |
35 | #include <brcmu_wifi.h> | |
36 | #include "sdio_host.h" | |
5b435de0 | 37 | #include "dhd_dbg.h" |
a8a363ac | 38 | #include "dhd_bus.h" |
5b435de0 AS |
39 | |
40 | #define SDIO_VENDOR_ID_BROADCOM 0x02d0 | |
41 | ||
42 | #define DMA_ALIGN_MASK 0x03 | |
43 | ||
369508c5 | 44 | #define SDIO_DEVICE_ID_BROADCOM_43143 43143 |
4a1c02ce | 45 | #define SDIO_DEVICE_ID_BROADCOM_43241 0x4324 |
5b435de0 | 46 | #define SDIO_DEVICE_ID_BROADCOM_4329 0x4329 |
ce2d7d7e | 47 | #define SDIO_DEVICE_ID_BROADCOM_4330 0x4330 |
85a4a1c3 | 48 | #define SDIO_DEVICE_ID_BROADCOM_4334 0x4334 |
6a1c7483 | 49 | #define SDIO_DEVICE_ID_BROADCOM_4335 0x4335 |
5b435de0 AS |
50 | |
51 | #define SDIO_FUNC1_BLOCKSIZE 64 | |
52 | #define SDIO_FUNC2_BLOCKSIZE 512 | |
53 | ||
54 | /* devices we support, null terminated */ | |
55 | static const struct sdio_device_id brcmf_sdmmc_ids[] = { | |
369508c5 | 56 | {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_43143)}, |
4a1c02ce | 57 | {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_43241)}, |
5b435de0 | 58 | {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_4329)}, |
ce2d7d7e | 59 | {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_4330)}, |
85a4a1c3 | 60 | {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_4334)}, |
6a1c7483 | 61 | {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_4335)}, |
5b435de0 AS |
62 | { /* end: all zeroes */ }, |
63 | }; | |
64 | MODULE_DEVICE_TABLE(sdio, brcmf_sdmmc_ids); | |
65 | ||
668761ac HM |
66 | static struct brcmfmac_sdio_platform_data *brcmfmac_sdio_pdata; |
67 | ||
ba89bf19 | 68 | |
78b3f1c5 | 69 | bool |
5b435de0 AS |
70 | brcmf_pm_resume_error(struct brcmf_sdio_dev *sdiodev) |
71 | { | |
72 | bool is_err = false; | |
73 | #ifdef CONFIG_PM_SLEEP | |
74 | is_err = atomic_read(&sdiodev->suspend); | |
75 | #endif | |
76 | return is_err; | |
77 | } | |
78 | ||
78b3f1c5 | 79 | void |
5b435de0 AS |
80 | brcmf_pm_resume_wait(struct brcmf_sdio_dev *sdiodev, wait_queue_head_t *wq) |
81 | { | |
82 | #ifdef CONFIG_PM_SLEEP | |
83 | int retry = 0; | |
84 | while (atomic_read(&sdiodev->suspend) && retry++ != 30) | |
85 | wait_event_timeout(*wq, false, HZ/100); | |
86 | #endif | |
87 | } | |
88 | ||
89 | static inline int brcmf_sdioh_f0_write_byte(struct brcmf_sdio_dev *sdiodev, | |
90 | uint regaddr, u8 *byte) | |
91 | { | |
92 | struct sdio_func *sdfunc = sdiodev->func[0]; | |
93 | int err_ret; | |
94 | ||
95 | /* | |
96 | * Can only directly write to some F0 registers. | |
97 | * Handle F2 enable/disable and Abort command | |
98 | * as a special case. | |
99 | */ | |
100 | if (regaddr == SDIO_CCCR_IOEx) { | |
101 | sdfunc = sdiodev->func[2]; | |
102 | if (sdfunc) { | |
5b435de0 AS |
103 | if (*byte & SDIO_FUNC_ENABLE_2) { |
104 | /* Enable Function 2 */ | |
105 | err_ret = sdio_enable_func(sdfunc); | |
106 | if (err_ret) | |
5e8149f5 | 107 | brcmf_err("enable F2 failed:%d\n", |
5b435de0 AS |
108 | err_ret); |
109 | } else { | |
110 | /* Disable Function 2 */ | |
111 | err_ret = sdio_disable_func(sdfunc); | |
112 | if (err_ret) | |
5e8149f5 | 113 | brcmf_err("Disable F2 failed:%d\n", |
5b435de0 AS |
114 | err_ret); |
115 | } | |
5b435de0 | 116 | } |
ba89bf19 FL |
117 | } else if ((regaddr == SDIO_CCCR_ABORT) || |
118 | (regaddr == SDIO_CCCR_IENx)) { | |
1cc26990 FL |
119 | sdfunc = kmemdup(sdiodev->func[0], sizeof(struct sdio_func), |
120 | GFP_KERNEL); | |
121 | if (!sdfunc) | |
122 | return -ENOMEM; | |
123 | sdfunc->num = 0; | |
5b435de0 | 124 | sdio_writeb(sdfunc, *byte, regaddr, &err_ret); |
1cc26990 | 125 | kfree(sdfunc); |
5b435de0 | 126 | } else if (regaddr < 0xF0) { |
5e8149f5 | 127 | brcmf_err("F0 Wr:0x%02x: write disallowed\n", regaddr); |
5b435de0 AS |
128 | err_ret = -EPERM; |
129 | } else { | |
5b435de0 | 130 | sdio_f0_writeb(sdfunc, *byte, regaddr, &err_ret); |
5b435de0 AS |
131 | } |
132 | ||
133 | return err_ret; | |
134 | } | |
135 | ||
136 | int brcmf_sdioh_request_byte(struct brcmf_sdio_dev *sdiodev, uint rw, uint func, | |
137 | uint regaddr, u8 *byte) | |
138 | { | |
139 | int err_ret; | |
140 | ||
c3203374 | 141 | brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x\n", rw, func, regaddr); |
5b435de0 AS |
142 | |
143 | brcmf_pm_resume_wait(sdiodev, &sdiodev->request_byte_wait); | |
144 | if (brcmf_pm_resume_error(sdiodev)) | |
145 | return -EIO; | |
146 | ||
147 | if (rw && func == 0) { | |
148 | /* handle F0 separately */ | |
149 | err_ret = brcmf_sdioh_f0_write_byte(sdiodev, regaddr, byte); | |
150 | } else { | |
5b435de0 AS |
151 | if (rw) /* CMD52 Write */ |
152 | sdio_writeb(sdiodev->func[func], *byte, regaddr, | |
153 | &err_ret); | |
154 | else if (func == 0) { | |
155 | *byte = sdio_f0_readb(sdiodev->func[func], regaddr, | |
156 | &err_ret); | |
157 | } else { | |
158 | *byte = sdio_readb(sdiodev->func[func], regaddr, | |
159 | &err_ret); | |
160 | } | |
5b435de0 AS |
161 | } |
162 | ||
163 | if (err_ret) | |
5e8149f5 | 164 | brcmf_err("Failed to %s byte F%d:@0x%05x=%02x, Err: %d\n", |
5b435de0 AS |
165 | rw ? "write" : "read", func, regaddr, *byte, err_ret); |
166 | ||
167 | return err_ret; | |
168 | } | |
169 | ||
170 | int brcmf_sdioh_request_word(struct brcmf_sdio_dev *sdiodev, | |
171 | uint rw, uint func, uint addr, u32 *word, | |
172 | uint nbytes) | |
173 | { | |
174 | int err_ret = -EIO; | |
175 | ||
176 | if (func == 0) { | |
5e8149f5 | 177 | brcmf_err("Only CMD52 allowed to F0\n"); |
5b435de0 AS |
178 | return -EINVAL; |
179 | } | |
180 | ||
c3203374 | 181 | brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x, nbytes=%d\n", |
5b435de0 AS |
182 | rw, func, addr, nbytes); |
183 | ||
184 | brcmf_pm_resume_wait(sdiodev, &sdiodev->request_word_wait); | |
185 | if (brcmf_pm_resume_error(sdiodev)) | |
186 | return -EIO; | |
5b435de0 AS |
187 | |
188 | if (rw) { /* CMD52 Write */ | |
189 | if (nbytes == 4) | |
190 | sdio_writel(sdiodev->func[func], *word, addr, | |
191 | &err_ret); | |
192 | else if (nbytes == 2) | |
193 | sdio_writew(sdiodev->func[func], (*word & 0xFFFF), | |
194 | addr, &err_ret); | |
195 | else | |
5e8149f5 | 196 | brcmf_err("Invalid nbytes: %d\n", nbytes); |
5b435de0 AS |
197 | } else { /* CMD52 Read */ |
198 | if (nbytes == 4) | |
199 | *word = sdio_readl(sdiodev->func[func], addr, &err_ret); | |
200 | else if (nbytes == 2) | |
201 | *word = sdio_readw(sdiodev->func[func], addr, | |
202 | &err_ret) & 0xFFFF; | |
203 | else | |
5e8149f5 | 204 | brcmf_err("Invalid nbytes: %d\n", nbytes); |
5b435de0 AS |
205 | } |
206 | ||
5b435de0 | 207 | if (err_ret) |
5e8149f5 | 208 | brcmf_err("Failed to %s word, Err: 0x%08x\n", |
5b435de0 AS |
209 | rw ? "write" : "read", err_ret); |
210 | ||
211 | return err_ret; | |
212 | } | |
213 | ||
5b435de0 AS |
214 | static int brcmf_sdioh_get_cisaddr(struct brcmf_sdio_dev *sdiodev, u32 regaddr) |
215 | { | |
216 | /* read 24 bits and return valid 17 bit addr */ | |
d8b3fc59 | 217 | int i, ret; |
5b435de0 AS |
218 | u32 scratch, regdata; |
219 | __le32 scratch_le; | |
220 | u8 *ptr = (u8 *)&scratch_le; | |
221 | ||
222 | for (i = 0; i < 3; i++) { | |
d8b3fc59 FL |
223 | regdata = brcmf_sdio_regrl(sdiodev, regaddr, &ret); |
224 | if (ret != 0) | |
5e8149f5 | 225 | brcmf_err("Can't read!\n"); |
5b435de0 AS |
226 | |
227 | *ptr++ = (u8) regdata; | |
228 | regaddr++; | |
229 | } | |
230 | ||
231 | /* Only the lower 17-bits are valid */ | |
232 | scratch = le32_to_cpu(scratch_le); | |
233 | scratch &= 0x0001FFFF; | |
234 | return scratch; | |
235 | } | |
236 | ||
237 | static int brcmf_sdioh_enablefuncs(struct brcmf_sdio_dev *sdiodev) | |
238 | { | |
239 | int err_ret; | |
240 | u32 fbraddr; | |
241 | u8 func; | |
242 | ||
c3203374 | 243 | brcmf_dbg(SDIO, "\n"); |
5b435de0 AS |
244 | |
245 | /* Get the Card's common CIS address */ | |
246 | sdiodev->func_cis_ptr[0] = brcmf_sdioh_get_cisaddr(sdiodev, | |
247 | SDIO_CCCR_CIS); | |
c3203374 | 248 | brcmf_dbg(SDIO, "Card's Common CIS Ptr = 0x%x\n", |
5b435de0 AS |
249 | sdiodev->func_cis_ptr[0]); |
250 | ||
251 | /* Get the Card's function CIS (for each function) */ | |
252 | for (fbraddr = SDIO_FBR_BASE(1), func = 1; | |
253 | func <= sdiodev->num_funcs; func++, fbraddr += SDIOD_FBR_SIZE) { | |
254 | sdiodev->func_cis_ptr[func] = | |
255 | brcmf_sdioh_get_cisaddr(sdiodev, SDIO_FBR_CIS + fbraddr); | |
c3203374 | 256 | brcmf_dbg(SDIO, "Function %d CIS Ptr = 0x%x\n", |
5b435de0 AS |
257 | func, sdiodev->func_cis_ptr[func]); |
258 | } | |
259 | ||
260 | /* Enable Function 1 */ | |
5b435de0 | 261 | err_ret = sdio_enable_func(sdiodev->func[1]); |
5b435de0 | 262 | if (err_ret) |
5e8149f5 | 263 | brcmf_err("Failed to enable F1 Err: 0x%08x\n", err_ret); |
5b435de0 AS |
264 | |
265 | return false; | |
266 | } | |
267 | ||
268 | /* | |
269 | * Public entry points & extern's | |
270 | */ | |
271 | int brcmf_sdioh_attach(struct brcmf_sdio_dev *sdiodev) | |
272 | { | |
273 | int err_ret = 0; | |
274 | ||
c3203374 | 275 | brcmf_dbg(SDIO, "\n"); |
5b435de0 AS |
276 | |
277 | sdiodev->num_funcs = 2; | |
278 | ||
279 | sdio_claim_host(sdiodev->func[1]); | |
38b0b0dd | 280 | |
5b435de0 | 281 | err_ret = sdio_set_block_size(sdiodev->func[1], SDIO_FUNC1_BLOCKSIZE); |
5b435de0 | 282 | if (err_ret) { |
5e8149f5 | 283 | brcmf_err("Failed to set F1 blocksize\n"); |
5b435de0 AS |
284 | goto out; |
285 | } | |
286 | ||
5b435de0 | 287 | err_ret = sdio_set_block_size(sdiodev->func[2], SDIO_FUNC2_BLOCKSIZE); |
5b435de0 | 288 | if (err_ret) { |
5e8149f5 | 289 | brcmf_err("Failed to set F2 blocksize\n"); |
5b435de0 AS |
290 | goto out; |
291 | } | |
292 | ||
293 | brcmf_sdioh_enablefuncs(sdiodev); | |
294 | ||
295 | out: | |
38b0b0dd | 296 | sdio_release_host(sdiodev->func[1]); |
c3203374 | 297 | brcmf_dbg(SDIO, "Done\n"); |
5b435de0 AS |
298 | return err_ret; |
299 | } | |
300 | ||
301 | void brcmf_sdioh_detach(struct brcmf_sdio_dev *sdiodev) | |
302 | { | |
c3203374 | 303 | brcmf_dbg(SDIO, "\n"); |
5b435de0 AS |
304 | |
305 | /* Disable Function 2 */ | |
306 | sdio_claim_host(sdiodev->func[2]); | |
307 | sdio_disable_func(sdiodev->func[2]); | |
308 | sdio_release_host(sdiodev->func[2]); | |
309 | ||
310 | /* Disable Function 1 */ | |
311 | sdio_claim_host(sdiodev->func[1]); | |
312 | sdio_disable_func(sdiodev->func[1]); | |
313 | sdio_release_host(sdiodev->func[1]); | |
314 | ||
315 | } | |
316 | ||
317 | static int brcmf_ops_sdio_probe(struct sdio_func *func, | |
5b3c1832 | 318 | const struct sdio_device_id *id) |
5b435de0 | 319 | { |
5b3c1832 | 320 | int err; |
5b435de0 | 321 | struct brcmf_sdio_dev *sdiodev; |
655713be | 322 | struct brcmf_bus *bus_if; |
ba89bf19 | 323 | |
c3203374 AS |
324 | brcmf_dbg(SDIO, "Enter\n"); |
325 | brcmf_dbg(SDIO, "Class=%x\n", func->class); | |
326 | brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor); | |
327 | brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device); | |
328 | brcmf_dbg(SDIO, "Function#: %d\n", func->num); | |
5b3c1832 HM |
329 | |
330 | /* Consume func num 1 but dont do anything with it. */ | |
331 | if (func->num == 1) | |
332 | return 0; | |
333 | ||
334 | /* Ignore anything but func 2 */ | |
335 | if (func->num != 2) | |
336 | return -ENODEV; | |
337 | ||
338 | bus_if = kzalloc(sizeof(struct brcmf_bus), GFP_KERNEL); | |
339 | if (!bus_if) | |
340 | return -ENOMEM; | |
341 | sdiodev = kzalloc(sizeof(struct brcmf_sdio_dev), GFP_KERNEL); | |
342 | if (!sdiodev) { | |
343 | kfree(bus_if); | |
344 | return -ENOMEM; | |
5b435de0 AS |
345 | } |
346 | ||
5b3c1832 HM |
347 | sdiodev->func[0] = func->card->sdio_func[0]; |
348 | sdiodev->func[1] = func->card->sdio_func[0]; | |
349 | sdiodev->func[2] = func; | |
350 | ||
351 | sdiodev->bus_if = bus_if; | |
352 | bus_if->bus_priv.sdio = sdiodev; | |
5b3c1832 HM |
353 | dev_set_drvdata(&func->dev, bus_if); |
354 | dev_set_drvdata(&sdiodev->func[1]->dev, bus_if); | |
355 | sdiodev->dev = &sdiodev->func[1]->dev; | |
668761ac | 356 | sdiodev->pdata = brcmfmac_sdio_pdata; |
5b3c1832 HM |
357 | |
358 | atomic_set(&sdiodev->suspend, false); | |
359 | init_waitqueue_head(&sdiodev->request_byte_wait); | |
360 | init_waitqueue_head(&sdiodev->request_word_wait); | |
5b3c1832 | 361 | init_waitqueue_head(&sdiodev->request_buffer_wait); |
5b3c1832 | 362 | |
c3203374 | 363 | brcmf_dbg(SDIO, "F2 found, calling brcmf_sdio_probe...\n"); |
5b3c1832 HM |
364 | err = brcmf_sdio_probe(sdiodev); |
365 | if (err) { | |
5e8149f5 | 366 | brcmf_err("F2 error, probe failed %d...\n", err); |
5b3c1832 | 367 | goto fail; |
5b435de0 | 368 | } |
c3203374 | 369 | brcmf_dbg(SDIO, "F2 init completed...\n"); |
5b3c1832 | 370 | return 0; |
5b435de0 | 371 | |
5b3c1832 HM |
372 | fail: |
373 | dev_set_drvdata(&func->dev, NULL); | |
374 | dev_set_drvdata(&sdiodev->func[1]->dev, NULL); | |
375 | kfree(sdiodev); | |
376 | kfree(bus_if); | |
377 | return err; | |
5b435de0 AS |
378 | } |
379 | ||
380 | static void brcmf_ops_sdio_remove(struct sdio_func *func) | |
381 | { | |
655713be | 382 | struct brcmf_bus *bus_if; |
5b435de0 | 383 | struct brcmf_sdio_dev *sdiodev; |
5b3c1832 | 384 | |
c3203374 AS |
385 | brcmf_dbg(SDIO, "Enter\n"); |
386 | brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor); | |
387 | brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device); | |
388 | brcmf_dbg(SDIO, "Function: %d\n", func->num); | |
5b435de0 | 389 | |
5b3c1832 HM |
390 | if (func->num != 1 && func->num != 2) |
391 | return; | |
392 | ||
393 | bus_if = dev_get_drvdata(&func->dev); | |
394 | if (bus_if) { | |
0a332e46 | 395 | sdiodev = bus_if->bus_priv.sdio; |
5b435de0 | 396 | brcmf_sdio_remove(sdiodev); |
5b3c1832 HM |
397 | |
398 | dev_set_drvdata(&sdiodev->func[1]->dev, NULL); | |
399 | dev_set_drvdata(&sdiodev->func[2]->dev, NULL); | |
400 | ||
655713be | 401 | kfree(bus_if); |
5b435de0 AS |
402 | kfree(sdiodev); |
403 | } | |
5b3c1832 | 404 | |
c3203374 | 405 | brcmf_dbg(SDIO, "Exit\n"); |
5b435de0 AS |
406 | } |
407 | ||
408 | #ifdef CONFIG_PM_SLEEP | |
409 | static int brcmf_sdio_suspend(struct device *dev) | |
410 | { | |
411 | mmc_pm_flag_t sdio_flags; | |
5b3c1832 HM |
412 | struct brcmf_bus *bus_if = dev_get_drvdata(dev); |
413 | struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio; | |
5b435de0 AS |
414 | int ret = 0; |
415 | ||
c3203374 | 416 | brcmf_dbg(SDIO, "\n"); |
5b435de0 | 417 | |
5b435de0 AS |
418 | atomic_set(&sdiodev->suspend, true); |
419 | ||
420 | sdio_flags = sdio_get_host_pm_caps(sdiodev->func[1]); | |
421 | if (!(sdio_flags & MMC_PM_KEEP_POWER)) { | |
5e8149f5 | 422 | brcmf_err("Host can't keep power while suspended\n"); |
5b435de0 AS |
423 | return -EINVAL; |
424 | } | |
425 | ||
426 | ret = sdio_set_host_pm_flags(sdiodev->func[1], MMC_PM_KEEP_POWER); | |
427 | if (ret) { | |
5e8149f5 | 428 | brcmf_err("Failed to set pm_flags\n"); |
5b435de0 AS |
429 | return ret; |
430 | } | |
431 | ||
432 | brcmf_sdio_wdtmr_enable(sdiodev, false); | |
433 | ||
434 | return ret; | |
435 | } | |
436 | ||
437 | static int brcmf_sdio_resume(struct device *dev) | |
438 | { | |
5b3c1832 HM |
439 | struct brcmf_bus *bus_if = dev_get_drvdata(dev); |
440 | struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio; | |
5b435de0 | 441 | |
5b435de0 AS |
442 | brcmf_sdio_wdtmr_enable(sdiodev, true); |
443 | atomic_set(&sdiodev->suspend, false); | |
444 | return 0; | |
445 | } | |
446 | ||
447 | static const struct dev_pm_ops brcmf_sdio_pm_ops = { | |
448 | .suspend = brcmf_sdio_suspend, | |
449 | .resume = brcmf_sdio_resume, | |
450 | }; | |
451 | #endif /* CONFIG_PM_SLEEP */ | |
452 | ||
453 | static struct sdio_driver brcmf_sdmmc_driver = { | |
454 | .probe = brcmf_ops_sdio_probe, | |
455 | .remove = brcmf_ops_sdio_remove, | |
668761ac | 456 | .name = BRCMFMAC_SDIO_PDATA_NAME, |
5b435de0 AS |
457 | .id_table = brcmf_sdmmc_ids, |
458 | #ifdef CONFIG_PM_SLEEP | |
459 | .drv = { | |
460 | .pm = &brcmf_sdio_pm_ops, | |
461 | }, | |
462 | #endif /* CONFIG_PM_SLEEP */ | |
463 | }; | |
464 | ||
ba89bf19 FL |
465 | static int brcmf_sdio_pd_probe(struct platform_device *pdev) |
466 | { | |
668761ac | 467 | int ret; |
ba89bf19 | 468 | |
668761ac | 469 | brcmf_dbg(SDIO, "Enter\n"); |
ba89bf19 | 470 | |
668761ac | 471 | brcmfmac_sdio_pdata = pdev->dev.platform_data; |
ba89bf19 | 472 | |
668761ac HM |
473 | if (brcmfmac_sdio_pdata->power_on) |
474 | brcmfmac_sdio_pdata->power_on(); | |
ba89bf19 FL |
475 | |
476 | ret = sdio_register_driver(&brcmf_sdmmc_driver); | |
ba89bf19 | 477 | if (ret) |
5e8149f5 | 478 | brcmf_err("sdio_register_driver failed: %d\n", ret); |
ba89bf19 FL |
479 | |
480 | return ret; | |
481 | } | |
482 | ||
668761ac | 483 | static int brcmf_sdio_pd_remove(struct platform_device *pdev) |
ba89bf19 | 484 | { |
c3203374 | 485 | brcmf_dbg(SDIO, "Enter\n"); |
ba89bf19 | 486 | |
668761ac HM |
487 | if (brcmfmac_sdio_pdata->power_off) |
488 | brcmfmac_sdio_pdata->power_off(); | |
489 | ||
ba89bf19 FL |
490 | sdio_unregister_driver(&brcmf_sdmmc_driver); |
491 | ||
668761ac | 492 | return 0; |
ba89bf19 FL |
493 | } |
494 | ||
668761ac HM |
495 | static struct platform_driver brcmf_sdio_pd = { |
496 | .remove = brcmf_sdio_pd_remove, | |
497 | .driver = { | |
f91f5f05 LC |
498 | .name = BRCMFMAC_SDIO_PDATA_NAME, |
499 | .owner = THIS_MODULE, | |
668761ac HM |
500 | } |
501 | }; | |
ba89bf19 | 502 | |
f3d7cdc3 | 503 | void brcmf_sdio_exit(void) |
5b435de0 | 504 | { |
c3203374 | 505 | brcmf_dbg(SDIO, "Enter\n"); |
5b435de0 | 506 | |
668761ac HM |
507 | if (brcmfmac_sdio_pdata) |
508 | platform_driver_unregister(&brcmf_sdio_pd); | |
509 | else | |
510 | sdio_unregister_driver(&brcmf_sdmmc_driver); | |
5b435de0 AS |
511 | } |
512 | ||
549040ab | 513 | void brcmf_sdio_init(void) |
5b435de0 | 514 | { |
3392c888 FL |
515 | int ret; |
516 | ||
c3203374 | 517 | brcmf_dbg(SDIO, "Enter\n"); |
5b435de0 | 518 | |
668761ac HM |
519 | ret = platform_driver_probe(&brcmf_sdio_pd, brcmf_sdio_pd_probe); |
520 | if (ret == -ENODEV) { | |
521 | brcmf_dbg(SDIO, "No platform data available, registering without.\n"); | |
522 | ret = sdio_register_driver(&brcmf_sdmmc_driver); | |
523 | } | |
3392c888 FL |
524 | |
525 | if (ret) | |
668761ac | 526 | brcmf_err("driver registration failed: %d\n", ret); |
5b435de0 | 527 | } |