1
2
3
4
5
6
7
8
9
10
11
12#include <linux/err.h>
13
14#include <linux/mmc/host.h>
15#include <linux/mmc/card.h>
16#include <linux/mmc/sdio.h>
17#include <linux/mmc/sdio_func.h>
18
19#include "core.h"
20#include "bus.h"
21#include "sdio_bus.h"
22#include "mmc_ops.h"
23#include "sd_ops.h"
24#include "sdio_ops.h"
25#include "sdio_cis.h"
26
27static int sdio_read_fbr(struct sdio_func *func)
28{
29 int ret;
30 unsigned char data;
31
32 ret = mmc_io_rw_direct(func->card, 0, 0,
33 SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF, 0, &data);
34 if (ret)
35 goto out;
36
37 data &= 0x0f;
38
39 if (data == 0x0f) {
40 ret = mmc_io_rw_direct(func->card, 0, 0,
41 SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF_EXT, 0, &data);
42 if (ret)
43 goto out;
44 }
45
46 func->class = data;
47
48out:
49 return ret;
50}
51
52static int sdio_init_func(struct mmc_card *card, unsigned int fn)
53{
54 int ret;
55 struct sdio_func *func;
56
57 BUG_ON(fn > SDIO_MAX_FUNCS);
58
59 func = sdio_alloc_func(card);
60 if (IS_ERR(func))
61 return PTR_ERR(func);
62
63 func->num = fn;
64
65 ret = sdio_read_fbr(func);
66 if (ret)
67 goto fail;
68
69 ret = sdio_read_func_cis(func);
70 if (ret)
71 goto fail;
72
73 card->sdio_func[fn - 1] = func;
74
75 return 0;
76
77fail:
78
79
80
81
82 sdio_remove_func(func);
83 return ret;
84}
85
86static int sdio_read_cccr(struct mmc_card *card)
87{
88 int ret;
89 int cccr_vsn;
90 unsigned char data;
91
92 memset(&card->cccr, 0, sizeof(struct sdio_cccr));
93
94 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CCCR, 0, &data);
95 if (ret)
96 goto out;
97
98 cccr_vsn = data & 0x0f;
99
100 if (cccr_vsn > SDIO_CCCR_REV_1_20) {
101 printk(KERN_ERR "%s: unrecognised CCCR structure version %d\n",
102 mmc_hostname(card->host), cccr_vsn);
103 return -EINVAL;
104 }
105
106 card->cccr.sdio_vsn = (data & 0xf0) >> 4;
107
108 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CAPS, 0, &data);
109 if (ret)
110 goto out;
111
112 if (data & SDIO_CCCR_CAP_SMB)
113 card->cccr.multi_block = 1;
114 if (data & SDIO_CCCR_CAP_LSC)
115 card->cccr.low_speed = 1;
116 if (data & SDIO_CCCR_CAP_4BLS)
117 card->cccr.wide_bus = 1;
118
119 if (cccr_vsn >= SDIO_CCCR_REV_1_10) {
120 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_POWER, 0, &data);
121 if (ret)
122 goto out;
123
124 if (data & SDIO_POWER_SMPC)
125 card->cccr.high_power = 1;
126 }
127
128 if (cccr_vsn >= SDIO_CCCR_REV_1_20) {
129 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &data);
130 if (ret)
131 goto out;
132
133 if (data & SDIO_SPEED_SHS)
134 card->cccr.high_speed = 1;
135 }
136
137out:
138 return ret;
139}
140
141static int sdio_enable_wide(struct mmc_card *card)
142{
143 int ret;
144 u8 ctrl;
145
146 if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
147 return 0;
148
149 if (card->cccr.low_speed && !card->cccr.wide_bus)
150 return 0;
151
152 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
153 if (ret)
154 return ret;
155
156 ctrl |= SDIO_BUS_WIDTH_4BIT;
157
158 ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
159 if (ret)
160 return ret;
161
162 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
163
164 return 0;
165}
166
167
168
169
170
171
172
173static int sdio_disable_cd(struct mmc_card *card)
174{
175 int ret;
176 u8 ctrl;
177
178 if (!card->cccr.disable_cd)
179 return 0;
180
181 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
182 if (ret)
183 return ret;
184
185 ctrl |= SDIO_BUS_CD_DISABLE;
186
187 return mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
188}
189
190
191
192
193static int sdio_enable_hs(struct mmc_card *card)
194{
195 int ret;
196 u8 speed;
197
198 if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
199 return 0;
200
201 if (!card->cccr.high_speed)
202 return 0;
203
204 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
205 if (ret)
206 return ret;
207
208 speed |= SDIO_SPEED_EHS;
209
210 ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
211 if (ret)
212 return ret;
213
214 mmc_card_set_highspeed(card);
215 mmc_set_timing(card->host, MMC_TIMING_SD_HS);
216
217 return 0;
218}
219
220
221
222
223
224
225
226static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
227 struct mmc_card *oldcard)
228{
229 struct mmc_card *card;
230 int err;
231
232 BUG_ON(!host);
233 WARN_ON(!host->claimed);
234
235
236
237
238 err = mmc_send_io_op_cond(host, host->ocr, &ocr);
239 if (err)
240 goto err;
241
242
243
244
245 if (mmc_host_is_spi(host)) {
246 err = mmc_spi_set_crc(host, use_spi_crc);
247 if (err)
248 goto err;
249 }
250
251
252
253
254 card = mmc_alloc_card(host, NULL);
255 if (IS_ERR(card)) {
256 err = PTR_ERR(card);
257 goto err;
258 }
259
260 card->type = MMC_TYPE_SDIO;
261
262
263
264
265 if (!mmc_host_is_spi(host)) {
266 err = mmc_send_relative_addr(host, &card->rca);
267 if (err)
268 goto remove;
269
270 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
271 }
272
273
274
275
276 if (!mmc_host_is_spi(host)) {
277 err = mmc_select_card(card);
278 if (err)
279 goto remove;
280 }
281
282
283
284
285 err = sdio_read_cccr(card);
286 if (err)
287 goto remove;
288
289
290
291
292 err = sdio_read_common_cis(card);
293 if (err)
294 goto remove;
295
296 if (oldcard) {
297 int same = (card->cis.vendor == oldcard->cis.vendor &&
298 card->cis.device == oldcard->cis.device);
299 mmc_remove_card(card);
300 if (!same) {
301 err = -ENOENT;
302 goto err;
303 }
304 card = oldcard;
305 return 0;
306 }
307
308
309
310
311 err = sdio_enable_hs(card);
312 if (err)
313 goto remove;
314
315
316
317
318 if (mmc_card_highspeed(card)) {
319
320
321
322
323
324
325 mmc_set_clock(host, 50000000);
326 } else {
327 mmc_set_clock(host, card->cis.max_dtr);
328 }
329
330
331
332
333 err = sdio_enable_wide(card);
334 if (err)
335 goto remove;
336
337 if (!oldcard)
338 host->card = card;
339 return 0;
340
341remove:
342 if (!oldcard)
343 mmc_remove_card(card);
344
345err:
346 return err;
347}
348
349
350
351
352static void mmc_sdio_remove(struct mmc_host *host)
353{
354 int i;
355
356 BUG_ON(!host);
357 BUG_ON(!host->card);
358
359 for (i = 0;i < host->card->sdio_funcs;i++) {
360 if (host->card->sdio_func[i]) {
361 sdio_remove_func(host->card->sdio_func[i]);
362 host->card->sdio_func[i] = NULL;
363 }
364 }
365
366 mmc_remove_card(host->card);
367 host->card = NULL;
368}
369
370
371
372
373static void mmc_sdio_detect(struct mmc_host *host)
374{
375 int err;
376
377 BUG_ON(!host);
378 BUG_ON(!host->card);
379
380 mmc_claim_host(host);
381
382
383
384
385 err = mmc_select_card(host->card);
386
387 mmc_release_host(host);
388
389 if (err) {
390 mmc_sdio_remove(host);
391
392 mmc_claim_host(host);
393 mmc_detach_bus(host);
394 mmc_release_host(host);
395 }
396}
397
398
399
400
401
402
403static int mmc_sdio_suspend(struct mmc_host *host)
404{
405 int i, err = 0;
406
407 for (i = 0; i < host->card->sdio_funcs; i++) {
408 struct sdio_func *func = host->card->sdio_func[i];
409 if (func && sdio_func_present(func) && func->dev.driver) {
410 const struct dev_pm_ops *pmops = func->dev.driver->pm;
411 if (!pmops || !pmops->suspend || !pmops->resume) {
412
413 err = -ENOSYS;
414 } else
415 err = pmops->suspend(&func->dev);
416 if (err)
417 break;
418 }
419 }
420 while (err && --i >= 0) {
421 struct sdio_func *func = host->card->sdio_func[i];
422 if (func && sdio_func_present(func) && func->dev.driver) {
423 const struct dev_pm_ops *pmops = func->dev.driver->pm;
424 pmops->resume(&func->dev);
425 }
426 }
427
428 return err;
429}
430
431static int mmc_sdio_resume(struct mmc_host *host)
432{
433 int i, err;
434
435 BUG_ON(!host);
436 BUG_ON(!host->card);
437
438
439 mmc_claim_host(host);
440 err = mmc_sdio_init_card(host, host->ocr, host->card);
441 mmc_release_host(host);
442
443
444
445
446
447
448
449
450
451
452
453 for (i = 0; !err && i < host->card->sdio_funcs; i++) {
454 struct sdio_func *func = host->card->sdio_func[i];
455 if (func && sdio_func_present(func) && func->dev.driver) {
456 const struct dev_pm_ops *pmops = func->dev.driver->pm;
457 err = pmops->resume(&func->dev);
458 }
459 }
460
461 return err;
462}
463
464static const struct mmc_bus_ops mmc_sdio_ops = {
465 .remove = mmc_sdio_remove,
466 .detect = mmc_sdio_detect,
467 .suspend = mmc_sdio_suspend,
468 .resume = mmc_sdio_resume,
469};
470
471
472
473
474
475int mmc_attach_sdio(struct mmc_host *host, u32 ocr)
476{
477 int err;
478 int i, funcs;
479 struct mmc_card *card;
480
481 BUG_ON(!host);
482 WARN_ON(!host->claimed);
483
484 mmc_attach_bus(host, &mmc_sdio_ops);
485
486
487
488
489
490 if (ocr & 0x7F) {
491 printk(KERN_WARNING "%s: card claims to support voltages "
492 "below the defined range. These will be ignored.\n",
493 mmc_hostname(host));
494 ocr &= ~0x7F;
495 }
496
497 host->ocr = mmc_select_voltage(host, ocr);
498
499
500
501
502 if (!host->ocr) {
503 err = -EINVAL;
504 goto err;
505 }
506
507
508
509
510 err = mmc_sdio_init_card(host, host->ocr, NULL);
511 if (err)
512 goto err;
513 card = host->card;
514
515
516
517
518
519 card->sdio_funcs = funcs = (ocr & 0x70000000) >> 28;
520
521
522
523
524 err = sdio_disable_cd(card);
525 if (err)
526 goto remove;
527
528
529
530
531 for (i = 0;i < funcs;i++) {
532 err = sdio_init_func(host->card, i + 1);
533 if (err)
534 goto remove;
535 }
536
537 mmc_release_host(host);
538
539
540
541
542 err = mmc_add_card(host->card);
543 if (err)
544 goto remove_added;
545
546
547
548
549 for (i = 0;i < funcs;i++) {
550 err = sdio_add_func(host->card->sdio_func[i]);
551 if (err)
552 goto remove_added;
553 }
554
555 return 0;
556
557
558remove_added:
559
560 mmc_sdio_remove(host);
561 mmc_claim_host(host);
562remove:
563
564 if (host->card)
565 mmc_sdio_remove(host);
566err:
567 mmc_detach_bus(host);
568 mmc_release_host(host);
569
570 printk(KERN_ERR "%s: error %d whilst initialising SDIO card\n",
571 mmc_hostname(host), err);
572
573 return err;
574}
575
576