1 /*
2 * Copyright (c) 2006-2018, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2012-01-13 weety first version
9 */
10
11 #include <drivers/mmcsd_core.h>
12 #include <drivers/sdio.h>
13 #include <drivers/sd.h>
14
15 #define DBG_ENABLE
16 #define DBG_SECTION_NAME "SDIO"
17 #ifdef RT_SDIO_DEBUG
18 #define DBG_LEVEL DBG_LOG
19 #else
20 #define DBG_LEVEL DBG_INFO
21 #endif /* RT_SDIO_DEBUG */
22 #define DBG_COLOR
23 #include <rtdbg.h>
24
25 #ifndef RT_SDIO_STACK_SIZE
26 #define RT_SDIO_STACK_SIZE 512
27 #endif
28 #ifndef RT_SDIO_THREAD_PRIORITY
29 #define RT_SDIO_THREAD_PRIORITY 0x40
30 #endif
31
32 static rt_list_t sdio_cards = RT_LIST_OBJECT_INIT(sdio_cards);
33 static rt_list_t sdio_drivers = RT_LIST_OBJECT_INIT(sdio_drivers);
34
35 struct sdio_card
36 {
37 struct rt_mmcsd_card *card;
38 rt_list_t list;
39 };
40
41 struct sdio_driver
42 {
43 struct rt_sdio_driver *drv;
44 rt_list_t list;
45 };
46
47 #define MIN(a, b) (a < b ? a : b)
48
49 static const rt_uint8_t speed_value[16] =
50 {
51 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80
52 };
53
54 static const rt_uint32_t speed_unit[8] =
55 {
56 10000, 100000, 1000000, 10000000, 0, 0, 0, 0
57 };
58
59 rt_inline rt_int32_t sdio_match_card(struct rt_mmcsd_card *card,
60 const struct rt_sdio_device_id *id);
61
62
sdio_io_send_op_cond(struct rt_mmcsd_host * host,rt_uint32_t ocr,rt_uint32_t * cmd5_resp)63 rt_int32_t sdio_io_send_op_cond(struct rt_mmcsd_host *host,
64 rt_uint32_t ocr,
65 rt_uint32_t *cmd5_resp)
66 {
67 struct rt_mmcsd_cmd cmd;
68 rt_int32_t i, err = 0;
69
70 RT_ASSERT(host != RT_NULL);
71
72 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
73
74 cmd.cmd_code = SD_IO_SEND_OP_COND;
75 cmd.arg = ocr;
76 cmd.flags = RESP_SPI_R4 | RESP_R4 | CMD_BCR;
77
78 for (i = 100; i; i--)
79 {
80 err = mmcsd_send_cmd(host, &cmd, 0);
81 if (err)
82 break;
83
84 /* if we're just probing, do a single pass */
85 if (ocr == 0)
86 break;
87
88 /* otherwise wait until reset completes */
89 if (controller_is_spi(host))
90 {
91 /*
92 * Both R1_SPI_IDLE and MMC_CARD_BUSY indicate
93 * an initialized card under SPI, but some cards
94 * (Marvell's) only behave when looking at this
95 * one.
96 */
97 if (cmd.resp[1] & CARD_BUSY)
98 break;
99 }
100 else
101 {
102 if (cmd.resp[0] & CARD_BUSY)
103 break;
104 }
105
106 err = -RT_ETIMEOUT;
107
108 mmcsd_delay_ms(10);
109 }
110
111 if (cmd5_resp)
112 *cmd5_resp = cmd.resp[controller_is_spi(host) ? 1 : 0];
113
114 return err;
115 }
116
sdio_io_rw_direct(struct rt_mmcsd_card * card,rt_int32_t rw,rt_uint32_t fn,rt_uint32_t reg_addr,rt_uint8_t * pdata,rt_uint8_t raw)117 rt_int32_t sdio_io_rw_direct(struct rt_mmcsd_card *card,
118 rt_int32_t rw,
119 rt_uint32_t fn,
120 rt_uint32_t reg_addr,
121 rt_uint8_t *pdata,
122 rt_uint8_t raw)
123 {
124 struct rt_mmcsd_cmd cmd;
125 rt_int32_t err;
126
127 RT_ASSERT(card != RT_NULL);
128 RT_ASSERT(fn <= SDIO_MAX_FUNCTIONS);
129 RT_ASSERT(pdata != RT_NULL);
130
131 if (reg_addr & ~SDIO_ARG_CMD53_REG_MASK)
132 return -RT_ERROR;
133
134 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
135
136 cmd.cmd_code = SD_IO_RW_DIRECT;
137 cmd.arg = rw ? SDIO_ARG_CMD52_WRITE : SDIO_ARG_CMD52_READ;
138 cmd.arg |= fn << SDIO_ARG_CMD52_FUNC_SHIFT;
139 cmd.arg |= raw ? SDIO_ARG_CMD52_RAW_FLAG : 0x00000000;
140 cmd.arg |= reg_addr << SDIO_ARG_CMD52_REG_SHIFT;
141 cmd.arg |= *pdata;
142 cmd.flags = RESP_SPI_R5 | RESP_R5 | CMD_AC;
143
144 err = mmcsd_send_cmd(card->host, &cmd, 0);
145 if (err)
146 return err;
147
148 if (!controller_is_spi(card->host))
149 {
150 if (cmd.resp[0] & R5_ERROR)
151 return -RT_EIO;
152 if (cmd.resp[0] & R5_FUNCTION_NUMBER)
153 return -RT_ERROR;
154 if (cmd.resp[0] & R5_OUT_OF_RANGE)
155 return -RT_ERROR;
156 }
157
158 if (!rw || raw)
159 {
160 if (controller_is_spi(card->host))
161 *pdata = (cmd.resp[0] >> 8) & 0xFF;
162 else
163 *pdata = cmd.resp[0] & 0xFF;
164 }
165
166 return 0;
167 }
168
sdio_io_rw_extended(struct rt_mmcsd_card * card,rt_int32_t rw,rt_uint32_t fn,rt_uint32_t addr,rt_int32_t op_code,rt_uint8_t * buf,rt_uint32_t blocks,rt_uint32_t blksize)169 rt_int32_t sdio_io_rw_extended(struct rt_mmcsd_card *card,
170 rt_int32_t rw,
171 rt_uint32_t fn,
172 rt_uint32_t addr,
173 rt_int32_t op_code,
174 rt_uint8_t *buf,
175 rt_uint32_t blocks,
176 rt_uint32_t blksize)
177 {
178 struct rt_mmcsd_req req;
179 struct rt_mmcsd_cmd cmd;
180 struct rt_mmcsd_data data;
181
182 RT_ASSERT(card != RT_NULL);
183 RT_ASSERT(fn <= SDIO_MAX_FUNCTIONS);
184 RT_ASSERT(blocks != 1 || blksize <= 512);
185 RT_ASSERT(blocks != 0);
186 RT_ASSERT(blksize != 0);
187
188 if (addr & ~SDIO_ARG_CMD53_REG_MASK)
189 return -RT_ERROR;
190
191 rt_memset(&req, 0, sizeof(struct rt_mmcsd_req));
192 rt_memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
193 rt_memset(&data, 0, sizeof(struct rt_mmcsd_data));
194
195 req.cmd = &cmd;
196 req.data = &data;
197
198 cmd.cmd_code = SD_IO_RW_EXTENDED;
199 cmd.arg = rw ? SDIO_ARG_CMD53_WRITE : SDIO_ARG_CMD53_READ;
200 cmd.arg |= fn << SDIO_ARG_CMD53_FUNC_SHIFT;
201 cmd.arg |= op_code ? SDIO_ARG_CMD53_INCREMENT : 0x00000000;
202 cmd.arg |= addr << SDIO_ARG_CMD53_REG_SHIFT;
203 if (blocks == 1 && blksize <= 512)
204 cmd.arg |= (blksize == 512) ? 0 : blksize; /* byte mode */
205 else
206 cmd.arg |= SDIO_ARG_CMD53_BLOCK_MODE | blocks; /* block mode */
207 cmd.flags = RESP_SPI_R5 | RESP_R5 | CMD_ADTC;
208
209 data.blksize = blksize;
210 data.blks = blocks;
211 data.flags = rw ? DATA_DIR_WRITE : DATA_DIR_READ;
212 data.buf = (rt_uint32_t *)buf;
213
214 mmcsd_set_data_timeout(&data, card);
215
216 mmcsd_send_request(card->host, &req);
217
218 if (cmd.err)
219 return cmd.err;
220 if (data.err)
221 return data.err;
222
223 if (!controller_is_spi(card->host))
224 {
225 if (cmd.resp[0] & R5_ERROR)
226 return -RT_EIO;
227 if (cmd.resp[0] & R5_FUNCTION_NUMBER)
228 return -RT_ERROR;
229 if (cmd.resp[0] & R5_OUT_OF_RANGE)
230 return -RT_ERROR;
231 }
232
233 return 0;
234 }
235
sdio_max_block_size(struct rt_sdio_function * func)236 rt_inline rt_uint32_t sdio_max_block_size(struct rt_sdio_function *func)
237 {
238 rt_uint32_t size = MIN(func->card->host->max_seg_size,
239 func->card->host->max_blk_size);
240 size = MIN(size, func->max_blk_size);
241
242 return MIN(size, 512u); /* maximum size for byte mode */
243 }
244
sdio_io_rw_extended_block(struct rt_sdio_function * func,rt_int32_t rw,rt_uint32_t addr,rt_int32_t op_code,rt_uint8_t * buf,rt_uint32_t len)245 rt_int32_t sdio_io_rw_extended_block(struct rt_sdio_function *func,
246 rt_int32_t rw,
247 rt_uint32_t addr,
248 rt_int32_t op_code,
249 rt_uint8_t *buf,
250 rt_uint32_t len)
251 {
252 rt_int32_t ret;
253 rt_uint32_t left_size;
254 rt_uint32_t max_blks, blks;
255
256 left_size = len;
257
258 /* Do the bulk of the transfer using block mode (if supported). */
259 if (func->card->cccr.multi_block && (len > sdio_max_block_size(func)))
260 {
261 max_blks = MIN(func->card->host->max_blk_count,
262 func->card->host->max_seg_size / func->cur_blk_size);
263 max_blks = MIN(max_blks, 511u);
264
265 while (left_size > func->cur_blk_size)
266 {
267 blks = left_size / func->cur_blk_size;
268 if (blks > max_blks)
269 blks = max_blks;
270 len = blks * func->cur_blk_size;
271
272 ret = sdio_io_rw_extended(func->card, rw, func->num,
273 addr, op_code, buf, blks, func->cur_blk_size);
274 if (ret)
275 return ret;
276
277 left_size -= len;
278 buf += len;
279 if (op_code)
280 addr += len;
281 }
282 }
283
284 while (left_size > 0)
285 {
286 len = MIN(left_size, sdio_max_block_size(func));
287
288 ret = sdio_io_rw_extended(func->card, rw, func->num,
289 addr, op_code, buf, 1, len);
290 if (ret)
291 return ret;
292
293 left_size -= len;
294 buf += len;
295 if (op_code)
296 addr += len;
297 }
298
299 return 0;
300 }
301
sdio_io_readb(struct rt_sdio_function * func,rt_uint32_t reg,rt_int32_t * err)302 rt_uint8_t sdio_io_readb(struct rt_sdio_function *func,
303 rt_uint32_t reg,
304 rt_int32_t *err)
305 {
306 rt_uint8_t data = 0;
307 rt_int32_t ret;
308
309 ret = sdio_io_rw_direct(func->card, 0, func->num, reg, &data, 0);
310
311 if (err)
312 {
313 *err = ret;
314 }
315
316 return data;
317 }
318
sdio_io_writeb(struct rt_sdio_function * func,rt_uint32_t reg,rt_uint8_t data)319 rt_int32_t sdio_io_writeb(struct rt_sdio_function *func,
320 rt_uint32_t reg,
321 rt_uint8_t data)
322 {
323 return sdio_io_rw_direct(func->card, 1, func->num, reg, &data, 0);
324 }
325
sdio_io_readw(struct rt_sdio_function * func,rt_uint32_t addr,rt_int32_t * err)326 rt_uint16_t sdio_io_readw(struct rt_sdio_function *func,
327 rt_uint32_t addr,
328 rt_int32_t *err)
329 {
330 rt_int32_t ret;
331 rt_uint32_t dmabuf;
332
333 if (err)
334 *err = 0;
335
336 ret = sdio_io_rw_extended_block(func, 0, addr, 1, (rt_uint8_t *)&dmabuf, 2);
337 if (ret)
338 {
339 if (err)
340 *err = ret;
341 }
342
343 return (rt_uint16_t)dmabuf;
344 }
345
sdio_io_writew(struct rt_sdio_function * func,rt_uint16_t data,rt_uint32_t addr)346 rt_int32_t sdio_io_writew(struct rt_sdio_function *func,
347 rt_uint16_t data,
348 rt_uint32_t addr)
349 {
350 rt_uint32_t dmabuf = data;
351
352 return sdio_io_rw_extended_block(func, 1, addr, 1, (rt_uint8_t *)&dmabuf, 2);
353 }
354
sdio_io_readl(struct rt_sdio_function * func,rt_uint32_t addr,rt_int32_t * err)355 rt_uint32_t sdio_io_readl(struct rt_sdio_function *func,
356 rt_uint32_t addr,
357 rt_int32_t *err)
358 {
359 rt_int32_t ret;
360 rt_uint32_t dmabuf;
361
362 if (err)
363 *err = 0;
364
365 ret = sdio_io_rw_extended_block(func, 0, addr, 1, (rt_uint8_t *)&dmabuf, 4);
366 if (ret)
367 {
368 if (err)
369 *err = ret;
370 }
371
372 return dmabuf;
373 }
374
sdio_io_writel(struct rt_sdio_function * func,rt_uint32_t data,rt_uint32_t addr)375 rt_int32_t sdio_io_writel(struct rt_sdio_function *func,
376 rt_uint32_t data,
377 rt_uint32_t addr)
378 {
379 rt_uint32_t dmabuf = data;
380
381 return sdio_io_rw_extended_block(func, 1, addr, 1, (rt_uint8_t *)&dmabuf, 4);
382 }
383
sdio_io_read_multi_fifo_b(struct rt_sdio_function * func,rt_uint32_t addr,rt_uint8_t * buf,rt_uint32_t len)384 rt_int32_t sdio_io_read_multi_fifo_b(struct rt_sdio_function *func,
385 rt_uint32_t addr,
386 rt_uint8_t *buf,
387 rt_uint32_t len)
388 {
389 return sdio_io_rw_extended_block(func, 0, addr, 0, buf, len);
390 }
391
sdio_io_write_multi_fifo_b(struct rt_sdio_function * func,rt_uint32_t addr,rt_uint8_t * buf,rt_uint32_t len)392 rt_int32_t sdio_io_write_multi_fifo_b(struct rt_sdio_function *func,
393 rt_uint32_t addr,
394 rt_uint8_t *buf,
395 rt_uint32_t len)
396 {
397 return sdio_io_rw_extended_block(func, 1, addr, 0, buf, len);
398 }
399
sdio_io_read_multi_incr_b(struct rt_sdio_function * func,rt_uint32_t addr,rt_uint8_t * buf,rt_uint32_t len)400 rt_int32_t sdio_io_read_multi_incr_b(struct rt_sdio_function *func,
401 rt_uint32_t addr,
402 rt_uint8_t *buf,
403 rt_uint32_t len)
404 {
405 return sdio_io_rw_extended_block(func, 0, addr, 1, buf, len);
406 }
407
sdio_io_write_multi_incr_b(struct rt_sdio_function * func,rt_uint32_t addr,rt_uint8_t * buf,rt_uint32_t len)408 rt_int32_t sdio_io_write_multi_incr_b(struct rt_sdio_function *func,
409 rt_uint32_t addr,
410 rt_uint8_t *buf,
411 rt_uint32_t len)
412 {
413 return sdio_io_rw_extended_block(func, 1, addr, 1, buf, len);
414 }
415
sdio_read_cccr(struct rt_mmcsd_card * card)416 static rt_int32_t sdio_read_cccr(struct rt_mmcsd_card *card)
417 {
418 rt_int32_t ret;
419 rt_int32_t cccr_version;
420 rt_uint8_t data;
421
422 rt_memset(&card->cccr, 0, sizeof(struct rt_sdio_cccr));
423
424 data = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_CCCR_REV, &ret);
425 if (ret)
426 goto out;
427
428 cccr_version = data & 0x0f;
429
430 if (cccr_version > SDIO_CCCR_REV_3_00)
431 {
432 LOG_E("unrecognised CCCR structure version %d", cccr_version);
433
434 return -RT_ERROR;
435 }
436
437 card->cccr.sdio_version = (data & 0xf0) >> 4;
438
439 data = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_CARD_CAPS, &ret);
440 if (ret)
441 goto out;
442
443 if (data & SDIO_CCCR_CAP_SMB)
444 card->cccr.multi_block = 1;
445 if (data & SDIO_CCCR_CAP_LSC)
446 card->cccr.low_speed = 1;
447 if (data & SDIO_CCCR_CAP_4BLS)
448 card->cccr.low_speed_4 = 1;
449 if (data & SDIO_CCCR_CAP_4BLS)
450 card->cccr.bus_width = 1;
451
452 if (cccr_version >= SDIO_CCCR_REV_1_10)
453 {
454 data = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_POWER_CTRL, &ret);
455 if (ret)
456 goto out;
457
458 if (data & SDIO_POWER_SMPC)
459 card->cccr.power_ctrl = 1;
460 }
461
462 if (cccr_version >= SDIO_CCCR_REV_1_20)
463 {
464 data = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_SPEED, &ret);
465 if (ret)
466 goto out;
467
468 if (data & SDIO_SPEED_SHS)
469 card->cccr.high_speed = 1;
470 }
471
472 out:
473 return ret;
474 }
475
cistpl_funce_func0(struct rt_mmcsd_card * card,const rt_uint8_t * buf,rt_uint32_t size)476 static rt_int32_t cistpl_funce_func0(struct rt_mmcsd_card *card,
477 const rt_uint8_t *buf,
478 rt_uint32_t size)
479 {
480 if (size < 0x04 || buf[0] != 0)
481 return -RT_ERROR;
482
483 /* TPLFE_FN0_BLK_SIZE */
484 card->cis.func0_blk_size = buf[1] | (buf[2] << 8);
485
486 /* TPLFE_MAX_TRAN_SPEED */
487 card->cis.max_tran_speed = speed_value[(buf[3] >> 3) & 15] *
488 speed_unit[buf[3] & 7];
489
490 return 0;
491 }
492
cistpl_funce_func(struct rt_sdio_function * func,const rt_uint8_t * buf,rt_uint32_t size)493 static rt_int32_t cistpl_funce_func(struct rt_sdio_function *func,
494 const rt_uint8_t *buf,
495 rt_uint32_t size)
496 {
497 rt_uint32_t version;
498 rt_uint32_t min_size;
499
500 version = func->card->cccr.sdio_version;
501 min_size = (version == SDIO_SDIO_REV_1_00) ? 28 : 42;
502
503 if (size < min_size || buf[0] != 1)
504 return -RT_ERROR;
505
506 /* TPLFE_MAX_BLK_SIZE */
507 func->max_blk_size = buf[12] | (buf[13] << 8);
508
509 /* TPLFE_ENABLE_TIMEOUT_VAL, present in ver 1.1 and above */
510 if (version > SDIO_SDIO_REV_1_00)
511 func->enable_timeout_val = (buf[28] | (buf[29] << 8)) * 10;
512 else
513 func->enable_timeout_val = 1000; /* 1000ms */
514
515 return 0;
516 }
517
sdio_read_cis(struct rt_sdio_function * func)518 static rt_int32_t sdio_read_cis(struct rt_sdio_function *func)
519 {
520 rt_int32_t ret;
521 struct rt_sdio_function_tuple *curr, **prev;
522 rt_uint32_t i, cisptr = 0;
523 rt_uint8_t data;
524 rt_uint8_t tpl_code, tpl_link;
525
526 struct rt_mmcsd_card *card = func->card;
527 struct rt_sdio_function *func0 = card->sdio_function[0];
528
529 RT_ASSERT(func0 != RT_NULL);
530
531 for (i = 0; i < 3; i++)
532 {
533 data = sdio_io_readb(func0,
534 SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_CIS + i, &ret);
535 if (ret)
536 return ret;
537 cisptr |= data << (i * 8);
538 }
539
540 prev = &func->tuples;
541
542 do {
543 tpl_code = sdio_io_readb(func0, cisptr++, &ret);
544 if (ret)
545 break;
546 tpl_link = sdio_io_readb(func0, cisptr++, &ret);
547 if (ret)
548 break;
549
550 if ((tpl_code == CISTPL_END) || (tpl_link == 0xff))
551 break;
552
553 if (tpl_code == CISTPL_NULL)
554 continue;
555
556
557 curr = rt_malloc(sizeof(struct rt_sdio_function_tuple) + tpl_link);
558 if (!curr)
559 return -RT_ENOMEM;
560 curr->data = (rt_uint8_t *)curr + sizeof(struct rt_sdio_function_tuple);
561
562 for (i = 0; i < tpl_link; i++)
563 {
564 curr->data[i] = sdio_io_readb(func0, cisptr + i, &ret);
565 if (ret)
566 break;
567 }
568 if (ret)
569 {
570 rt_free(curr);
571 break;
572 }
573
574 switch (tpl_code)
575 {
576 case CISTPL_MANFID:
577 if (tpl_link < 4)
578 {
579 LOG_D("bad CISTPL_MANFID length");
580 break;
581 }
582 if (func->num != 0)
583 {
584 func->manufacturer = curr->data[0];
585 func->manufacturer |= curr->data[1] << 8;
586 func->product = curr->data[2];
587 func->product |= curr->data[3] << 8;
588 }
589 else
590 {
591 card->cis.manufacturer = curr->data[0];
592 card->cis.manufacturer |= curr->data[1] << 8;
593 card->cis.product = curr->data[2];
594 card->cis.product |= curr->data[3] << 8;
595 }
596 break;
597 case CISTPL_FUNCE:
598 if (func->num != 0)
599 ret = cistpl_funce_func(func, curr->data, tpl_link);
600 else
601 ret = cistpl_funce_func0(card, curr->data, tpl_link);
602
603 if (ret)
604 {
605 LOG_D("bad CISTPL_FUNCE size %u "
606 "type %u", tpl_link, curr->data[0]);
607 }
608
609 break;
610 case CISTPL_VERS_1:
611 if (tpl_link < 2)
612 {
613 LOG_D("CISTPL_VERS_1 too short");
614 }
615 break;
616 default:
617 /* this tuple is unknown to the core */
618 curr->next = RT_NULL;
619 curr->code = tpl_code;
620 curr->size = tpl_link;
621 *prev = curr;
622 prev = &curr->next;
623 LOG_D( "function %d, CIS tuple code %#x, length %d",
624 func->num, tpl_code, tpl_link);
625 break;
626 }
627
628 cisptr += tpl_link;
629 } while (1);
630
631 /*
632 * Link in all unknown tuples found in the common CIS so that
633 * drivers don't have to go digging in two places.
634 */
635 if (func->num != 0)
636 *prev = func0->tuples;
637
638 return ret;
639 }
640
641
sdio_free_cis(struct rt_sdio_function * func)642 void sdio_free_cis(struct rt_sdio_function *func)
643 {
644 struct rt_sdio_function_tuple *tuple, *tmp;
645 struct rt_mmcsd_card *card = func->card;
646
647 tuple = func->tuples;
648
649 while (tuple && ((tuple != card->sdio_function[0]->tuples) || (!func->num)))
650 {
651 tmp = tuple;
652 tuple = tuple->next;
653 rt_free(tmp);
654 }
655
656 func->tuples = RT_NULL;
657 }
658
sdio_read_fbr(struct rt_sdio_function * func)659 static rt_int32_t sdio_read_fbr(struct rt_sdio_function *func)
660 {
661 rt_int32_t ret;
662 rt_uint8_t data;
663 struct rt_sdio_function *func0 = func->card->sdio_function[0];
664
665 data = sdio_io_readb(func0,
666 SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_STD_FUNC_IF, &ret);
667 if (ret)
668 goto err;
669
670 data &= 0x0f;
671
672 if (data == 0x0f)
673 {
674 data = sdio_io_readb(func0,
675 SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_STD_IF_EXT, &ret);
676 if (ret)
677 goto err;
678 }
679
680 func->func_code = data;
681
682 err:
683 return ret;
684 }
685
sdio_initialize_function(struct rt_mmcsd_card * card,rt_uint32_t func_num)686 static rt_int32_t sdio_initialize_function(struct rt_mmcsd_card *card,
687 rt_uint32_t func_num)
688 {
689 rt_int32_t ret;
690 struct rt_sdio_function *func;
691
692 RT_ASSERT(func_num <= SDIO_MAX_FUNCTIONS);
693
694 func = rt_malloc(sizeof(struct rt_sdio_function));
695 if (!func)
696 {
697 LOG_E("malloc rt_sdio_function failed");
698 ret = -RT_ENOMEM;
699 goto err;
700 }
701 rt_memset(func, 0, sizeof(struct rt_sdio_function));
702
703 func->card = card;
704 func->num = func_num;
705
706 ret = sdio_read_fbr(func);
707 if (ret)
708 goto err1;
709
710 ret = sdio_read_cis(func);
711 if (ret)
712 goto err1;
713
714 card->sdio_function[func_num] = func;
715
716 return 0;
717
718 err1:
719 sdio_free_cis(func);
720 rt_free(func);
721 card->sdio_function[func_num] = RT_NULL;
722 err:
723 return ret;
724 }
725
sdio_set_highspeed(struct rt_mmcsd_card * card)726 static rt_int32_t sdio_set_highspeed(struct rt_mmcsd_card *card)
727 {
728 rt_int32_t ret;
729 rt_uint8_t speed;
730
731 if (!(card->host->flags & MMCSD_SUP_HIGHSPEED))
732 return 0;
733
734 if (!card->cccr.high_speed)
735 return 0;
736
737 speed = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_SPEED, &ret);
738 if (ret)
739 return ret;
740
741 speed |= SDIO_SPEED_EHS;
742
743 ret = sdio_io_writeb(card->sdio_function[0], SDIO_REG_CCCR_SPEED, speed);
744 if (ret)
745 return ret;
746
747 card->flags |= CARD_FLAG_HIGHSPEED;
748
749 return 0;
750 }
751
sdio_set_bus_wide(struct rt_mmcsd_card * card)752 static rt_int32_t sdio_set_bus_wide(struct rt_mmcsd_card *card)
753 {
754 rt_int32_t ret;
755 rt_uint8_t busif;
756
757 if (!(card->host->flags & MMCSD_BUSWIDTH_4))
758 return 0;
759
760 if (card->cccr.low_speed && !card->cccr.bus_width)
761 return 0;
762
763 busif = sdio_io_readb(card->sdio_function[0], SDIO_REG_CCCR_BUS_IF, &ret);
764 if (ret)
765 return ret;
766
767 busif |= SDIO_BUS_WIDTH_4BIT;
768
769 ret = sdio_io_writeb(card->sdio_function[0], SDIO_REG_CCCR_BUS_IF, busif);
770 if (ret)
771 return ret;
772
773 mmcsd_set_bus_width(card->host, MMCSD_BUS_WIDTH_4);
774
775 return 0;
776 }
777
sdio_register_card(struct rt_mmcsd_card * card)778 static rt_int32_t sdio_register_card(struct rt_mmcsd_card *card)
779 {
780 struct sdio_card *sc;
781 struct sdio_driver *sd;
782 rt_list_t *l;
783
784 sc = rt_malloc(sizeof(struct sdio_card));
785 if (sc == RT_NULL)
786 {
787 LOG_E("malloc sdio card failed");
788 return -RT_ENOMEM;
789 }
790
791 sc->card = card;
792 rt_list_insert_after(&sdio_cards, &sc->list);
793
794 if (rt_list_isempty(&sdio_drivers))
795 {
796 goto out;
797 }
798
799 for (l = (&sdio_drivers)->next; l != &sdio_drivers; l = l->next)
800 {
801 sd = (struct sdio_driver *)rt_list_entry(l, struct sdio_driver, list);
802 if (sdio_match_card(card, sd->drv->id))
803 {
804 sd->drv->probe(card);
805 }
806 }
807
808 out:
809 return 0;
810 }
811
sdio_init_card(struct rt_mmcsd_host * host,rt_uint32_t ocr)812 static rt_int32_t sdio_init_card(struct rt_mmcsd_host *host, rt_uint32_t ocr)
813 {
814 rt_int32_t err = 0;
815 rt_int32_t i, function_num;
816 rt_uint32_t cmd5_resp;
817 struct rt_mmcsd_card *card;
818
819 err = sdio_io_send_op_cond(host, ocr, &cmd5_resp);
820 if (err)
821 goto err;
822
823 if (controller_is_spi(host))
824 {
825 err = mmcsd_spi_use_crc(host, host->spi_use_crc);
826 if (err)
827 goto err;
828 }
829
830 function_num = (cmd5_resp & 0x70000000) >> 28;
831
832 card = rt_malloc(sizeof(struct rt_mmcsd_card));
833 if (!card)
834 {
835 LOG_E("malloc card failed");
836 err = -RT_ENOMEM;
837 goto err;
838 }
839 rt_memset(card, 0, sizeof(struct rt_mmcsd_card));
840
841 card->card_type = CARD_TYPE_SDIO;
842 card->sdio_function_num = function_num;
843 card->host = host;
844 host->card = card;
845
846 card->sdio_function[0] = rt_malloc(sizeof(struct rt_sdio_function));
847 if (!card->sdio_function[0])
848 {
849 LOG_E("malloc sdio_func0 failed");
850 err = -RT_ENOMEM;
851 goto err1;
852 }
853 rt_memset(card->sdio_function[0], 0, sizeof(struct rt_sdio_function));
854 card->sdio_function[0]->card = card;
855 card->sdio_function[0]->num = 0;
856
857 if (!controller_is_spi(host))
858 {
859 err = mmcsd_get_card_addr(host, &card->rca);
860 if (err)
861 goto err2;
862
863 mmcsd_set_bus_mode(host, MMCSD_BUSMODE_PUSHPULL);
864 }
865
866 if (!controller_is_spi(host))
867 {
868 err = mmcsd_select_card(card);
869 if (err)
870 goto err2;
871 }
872
873 err = sdio_read_cccr(card);
874 if (err)
875 goto err2;
876
877 err = sdio_read_cis(card->sdio_function[0]);
878 if (err)
879 goto err2;
880
881 err = sdio_set_highspeed(card);
882 if (err)
883 goto err2;
884
885 if (card->flags & CARD_FLAG_HIGHSPEED)
886 {
887 mmcsd_set_clock(host, 50000000);
888 }
889 else
890 {
891 mmcsd_set_clock(host, card->cis.max_tran_speed);
892 }
893
894 err = sdio_set_bus_wide(card);
895 if (err)
896 goto err2;
897
898 for (i = 1; i < function_num + 1; i++)
899 {
900 err = sdio_initialize_function(card, i);
901 if (err)
902 goto err3;
903 }
904
905
906 /* register sdio card */
907 err = sdio_register_card(card);
908 if (err)
909 {
910 goto err3;
911 }
912
913 return 0;
914
915 err3:
916 if (host->card)
917 {
918 for (i = 1; i < host->card->sdio_function_num + 1; i++)
919 {
920 if (host->card->sdio_function[i])
921 {
922 sdio_free_cis(host->card->sdio_function[i]);
923 rt_free(host->card->sdio_function[i]);
924 host->card->sdio_function[i] = RT_NULL;
925 rt_free(host->card);
926 host->card = RT_NULL;
927 break;
928 }
929 }
930 }
931 err2:
932 if (host->card && host->card->sdio_function[0])
933 {
934 sdio_free_cis(host->card->sdio_function[0]);
935 rt_free(host->card->sdio_function[0]);
936 host->card->sdio_function[0] = RT_NULL;
937 }
938 err1:
939 if (host->card)
940 {
941 rt_free(host->card);
942 }
943 err:
944 LOG_E("error %d while initialising SDIO card", err);
945
946 return err;
947 }
948
init_sdio(struct rt_mmcsd_host * host,rt_uint32_t ocr)949 rt_int32_t init_sdio(struct rt_mmcsd_host *host, rt_uint32_t ocr)
950 {
951 rt_int32_t err;
952 rt_uint32_t current_ocr;
953
954 RT_ASSERT(host != RT_NULL);
955
956 if (ocr & 0x7F)
957 {
958 LOG_W("Card ocr below the defined voltage rang.");
959 ocr &= ~0x7F;
960 }
961
962 if (ocr & VDD_165_195)
963 {
964 LOG_W("Can't support the low voltage SDIO card.");
965 ocr &= ~VDD_165_195;
966 }
967
968 current_ocr = mmcsd_select_voltage(host, ocr);
969
970 if (!current_ocr)
971 {
972 err = -RT_ERROR;
973 goto err;
974 }
975
976 err = sdio_init_card(host, current_ocr);
977 if (err)
978 goto remove_card;
979
980 return 0;
981
982 remove_card:
983 rt_free(host->card);
984 host->card = RT_NULL;
985 err:
986
987 LOG_E("init SDIO card failed");
988
989 return err;
990 }
991
sdio_irq_thread(void * param)992 static void sdio_irq_thread(void *param)
993 {
994 rt_int32_t i, ret;
995 rt_uint8_t pending;
996 struct rt_mmcsd_card *card;
997 struct rt_mmcsd_host *host = (struct rt_mmcsd_host *)param;
998 RT_ASSERT(host != RT_NULL);
999 card = host->card;
1000 RT_ASSERT(card != RT_NULL);
1001
1002 while (1)
1003 {
1004 if (rt_sem_take(host->sdio_irq_sem, RT_WAITING_FOREVER) == RT_EOK)
1005 {
1006 mmcsd_host_lock(host);
1007 pending = sdio_io_readb(host->card->sdio_function[0],
1008 SDIO_REG_CCCR_INT_PEND, &ret);
1009 if (ret)
1010 {
1011 mmcsd_dbg("error %d reading SDIO_REG_CCCR_INT_PEND\n", ret);
1012 goto out;
1013 }
1014
1015 for (i = 1; i <= 7; i++)
1016 {
1017 if (pending & (1 << i))
1018 {
1019 struct rt_sdio_function *func = card->sdio_function[i];
1020 if (!func)
1021 {
1022 mmcsd_dbg("pending IRQ for "
1023 "non-existant function %d\n", func->num);
1024 goto out;
1025 }
1026 else if (func->irq_handler)
1027 {
1028 func->irq_handler(func);
1029 }
1030 else
1031 {
1032 mmcsd_dbg("pending IRQ with no register handler\n");
1033 goto out;
1034 }
1035 }
1036 }
1037
1038 out:
1039 mmcsd_host_unlock(host);
1040 if (host->flags & MMCSD_SUP_SDIO_IRQ)
1041 host->ops->enable_sdio_irq(host, 1);
1042 continue;
1043 }
1044 }
1045 }
1046
sdio_irq_thread_create(struct rt_mmcsd_card * card)1047 static rt_int32_t sdio_irq_thread_create(struct rt_mmcsd_card *card)
1048 {
1049 struct rt_mmcsd_host *host = card->host;
1050
1051 /* init semaphore and create sdio irq processing thread */
1052 if (!host->sdio_irq_num)
1053 {
1054 host->sdio_irq_num++;
1055 host->sdio_irq_sem = rt_sem_create("sdio_irq", 0, RT_IPC_FLAG_FIFO);
1056 RT_ASSERT(host->sdio_irq_sem != RT_NULL);
1057
1058 host->sdio_irq_thread = rt_thread_create("sdio_irq", sdio_irq_thread, host,
1059 RT_SDIO_STACK_SIZE, RT_SDIO_THREAD_PRIORITY, 20);
1060 if (host->sdio_irq_thread != RT_NULL)
1061 {
1062 rt_thread_startup(host->sdio_irq_thread);
1063 }
1064 }
1065
1066 return 0;
1067 }
1068
sdio_irq_thread_delete(struct rt_mmcsd_card * card)1069 static rt_int32_t sdio_irq_thread_delete(struct rt_mmcsd_card *card)
1070 {
1071 struct rt_mmcsd_host *host = card->host;
1072
1073 RT_ASSERT(host->sdio_irq_num > 0);
1074
1075 host->sdio_irq_num--;
1076 if (!host->sdio_irq_num)
1077 {
1078 if (host->flags & MMCSD_SUP_SDIO_IRQ)
1079 host->ops->enable_sdio_irq(host, 0);
1080 rt_sem_delete(host->sdio_irq_sem);
1081 host->sdio_irq_sem = RT_NULL;
1082 rt_thread_delete(host->sdio_irq_thread);
1083 host->sdio_irq_thread = RT_NULL;
1084 }
1085
1086 return 0;
1087 }
1088
sdio_attach_irq(struct rt_sdio_function * func,rt_sdio_irq_handler_t * handler)1089 rt_int32_t sdio_attach_irq(struct rt_sdio_function *func,
1090 rt_sdio_irq_handler_t *handler)
1091 {
1092 rt_int32_t ret;
1093 rt_uint8_t reg;
1094 struct rt_sdio_function *func0;
1095
1096 RT_ASSERT(func != RT_NULL);
1097 RT_ASSERT(func->card != RT_NULL);
1098
1099 func0 = func->card->sdio_function[0];
1100
1101 mmcsd_dbg("SDIO: enabling IRQ for function %d\n", func->num);
1102
1103 if (func->irq_handler)
1104 {
1105 mmcsd_dbg("SDIO: IRQ for already in use.\n");
1106
1107 return -RT_EBUSY;
1108 }
1109
1110 reg = sdio_io_readb(func0, SDIO_REG_CCCR_INT_EN, &ret);
1111 if (ret)
1112 return ret;
1113
1114 reg |= 1 << func->num;
1115
1116 reg |= 1; /* Master interrupt enable */
1117
1118 ret = sdio_io_writeb(func0, SDIO_REG_CCCR_INT_EN, reg);
1119 if (ret)
1120 return ret;
1121
1122 func->irq_handler = handler;
1123
1124 ret = sdio_irq_thread_create(func->card);
1125 if (ret)
1126 func->irq_handler = RT_NULL;
1127
1128 return ret;
1129 }
1130
sdio_detach_irq(struct rt_sdio_function * func)1131 rt_int32_t sdio_detach_irq(struct rt_sdio_function *func)
1132 {
1133 rt_int32_t ret;
1134 rt_uint8_t reg;
1135 struct rt_sdio_function *func0;
1136
1137 RT_ASSERT(func != RT_NULL);
1138 RT_ASSERT(func->card != RT_NULL);
1139
1140 func0 = func->card->sdio_function[0];
1141
1142 mmcsd_dbg("SDIO: disabling IRQ for function %d\n", func->num);
1143
1144 if (func->irq_handler)
1145 {
1146 func->irq_handler = RT_NULL;
1147 sdio_irq_thread_delete(func->card);
1148 }
1149
1150 reg = sdio_io_readb(func0, SDIO_REG_CCCR_INT_EN, &ret);
1151 if (ret)
1152 return ret;
1153
1154 reg &= ~(1 << func->num);
1155
1156 /* Disable master interrupt with the last function interrupt */
1157 if (!(reg & 0xFE))
1158 reg = 0;
1159
1160 ret = sdio_io_writeb(func0, SDIO_REG_CCCR_INT_EN, reg);
1161 if (ret)
1162 return ret;
1163
1164 return 0;
1165 }
1166
sdio_irq_wakeup(struct rt_mmcsd_host * host)1167 void sdio_irq_wakeup(struct rt_mmcsd_host *host)
1168 {
1169 if (host->flags & MMCSD_SUP_SDIO_IRQ)
1170 host->ops->enable_sdio_irq(host, 0);
1171 if (host->sdio_irq_sem)
1172 rt_sem_release(host->sdio_irq_sem);
1173 }
1174
sdio_enable_func(struct rt_sdio_function * func)1175 rt_int32_t sdio_enable_func(struct rt_sdio_function *func)
1176 {
1177 rt_int32_t ret;
1178 rt_uint8_t reg;
1179 rt_uint32_t timeout;
1180 struct rt_sdio_function *func0;
1181
1182 RT_ASSERT(func != RT_NULL);
1183 RT_ASSERT(func->card != RT_NULL);
1184
1185 func0 = func->card->sdio_function[0];
1186
1187 mmcsd_dbg("SDIO: enabling function %d\n", func->num);
1188
1189 reg = sdio_io_readb(func0, SDIO_REG_CCCR_IO_EN, &ret);
1190 if (ret)
1191 goto err;
1192
1193 reg |= 1 << func->num;
1194
1195 ret = sdio_io_writeb(func0, SDIO_REG_CCCR_IO_EN, reg);
1196 if (ret)
1197 goto err;
1198
1199 timeout = rt_tick_get() + func->enable_timeout_val * RT_TICK_PER_SECOND / 1000;
1200
1201 while (1)
1202 {
1203 reg = sdio_io_readb(func0, SDIO_REG_CCCR_IO_RDY, &ret);
1204 if (ret)
1205 goto err;
1206 if (reg & (1 << func->num))
1207 break;
1208 ret = -RT_ETIMEOUT;
1209 if (rt_tick_get() > timeout)
1210 goto err;
1211 }
1212
1213 mmcsd_dbg("SDIO: enabled function successfull\n");
1214
1215 return 0;
1216
1217 err:
1218 mmcsd_dbg("SDIO: failed to enable function %d\n", func->num);
1219 return ret;
1220 }
1221
sdio_disable_func(struct rt_sdio_function * func)1222 rt_int32_t sdio_disable_func(struct rt_sdio_function *func)
1223 {
1224 rt_int32_t ret;
1225 rt_uint8_t reg;
1226 struct rt_sdio_function *func0;
1227
1228 RT_ASSERT(func != RT_NULL);
1229 RT_ASSERT(func->card != RT_NULL);
1230
1231 func0 = func->card->sdio_function[0];
1232
1233 mmcsd_dbg("SDIO: disabling function %d\n", func->num);
1234
1235 reg = sdio_io_readb(func0, SDIO_REG_CCCR_IO_EN, &ret);
1236 if (ret)
1237 goto err;
1238
1239 reg &= ~(1 << func->num);
1240
1241 ret = sdio_io_writeb(func0, SDIO_REG_CCCR_IO_EN, reg);
1242 if (ret)
1243 goto err;
1244
1245 mmcsd_dbg("SDIO: disabled function successfull\n");
1246
1247 return 0;
1248
1249 err:
1250 mmcsd_dbg("SDIO: failed to disable function %d\n", func->num);
1251 return -RT_EIO;
1252 }
1253
sdio_set_drvdata(struct rt_sdio_function * func,void * data)1254 void sdio_set_drvdata(struct rt_sdio_function *func, void *data)
1255 {
1256 func->priv = data;
1257 }
1258
sdio_get_drvdata(struct rt_sdio_function * func)1259 void* sdio_get_drvdata(struct rt_sdio_function *func)
1260 {
1261 return func->priv;
1262 }
1263
sdio_set_block_size(struct rt_sdio_function * func,rt_uint32_t blksize)1264 rt_int32_t sdio_set_block_size(struct rt_sdio_function *func,
1265 rt_uint32_t blksize)
1266 {
1267 rt_int32_t ret;
1268 struct rt_sdio_function *func0 = func->card->sdio_function[0];
1269
1270 if (blksize > func->card->host->max_blk_size)
1271 return -RT_ERROR;
1272
1273 if (blksize == 0)
1274 {
1275 blksize = MIN(func->max_blk_size, func->card->host->max_blk_size);
1276 blksize = MIN(blksize, 512u);
1277 }
1278
1279 ret = sdio_io_writeb(func0, SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_BLKSIZE,
1280 blksize & 0xff);
1281 if (ret)
1282 return ret;
1283 ret = sdio_io_writeb(func0, SDIO_REG_FBR_BASE(func->num) + SDIO_REG_FBR_BLKSIZE + 1,
1284 (blksize >> 8) & 0xff);
1285 if (ret)
1286 return ret;
1287 func->cur_blk_size = blksize;
1288
1289 return 0;
1290 }
1291
sdio_match_card(struct rt_mmcsd_card * card,const struct rt_sdio_device_id * id)1292 rt_inline rt_int32_t sdio_match_card(struct rt_mmcsd_card *card,
1293 const struct rt_sdio_device_id *id)
1294 {
1295 rt_uint8_t num = 1;
1296
1297 if ((id->manufacturer != SDIO_ANY_MAN_ID) &&
1298 (id->manufacturer != card->cis.manufacturer))
1299 return 0;
1300
1301 while (num <= card->sdio_function_num)
1302 {
1303 if ((id->product != SDIO_ANY_PROD_ID) &&
1304 (id->product == card->sdio_function[num]->product))
1305 return 1;
1306 num++;
1307 }
1308
1309 return 0;
1310 }
1311
1312
sdio_match_driver(struct rt_sdio_device_id * id)1313 static struct rt_mmcsd_card *sdio_match_driver(struct rt_sdio_device_id *id)
1314 {
1315 rt_list_t *l;
1316 struct sdio_card *sc;
1317 struct rt_mmcsd_card *card;
1318
1319 for (l = (&sdio_cards)->next; l != &sdio_cards; l = l->next)
1320 {
1321 sc = (struct sdio_card *)rt_list_entry(l, struct sdio_card, list);
1322 card = sc->card;
1323
1324 if (sdio_match_card(card, id))
1325 {
1326 return card;
1327 }
1328 }
1329
1330 return RT_NULL;
1331 }
1332
sdio_register_driver(struct rt_sdio_driver * driver)1333 rt_int32_t sdio_register_driver(struct rt_sdio_driver *driver)
1334 {
1335 struct sdio_driver *sd;
1336 struct rt_mmcsd_card *card;
1337
1338 sd = rt_malloc(sizeof(struct sdio_driver));
1339 if (sd == RT_NULL)
1340 {
1341 LOG_E("malloc sdio driver failed");
1342
1343 return -RT_ENOMEM;
1344 }
1345
1346 sd->drv = driver;
1347 rt_list_insert_after(&sdio_drivers, &sd->list);
1348
1349 if (!rt_list_isempty(&sdio_cards))
1350 {
1351 card = sdio_match_driver(driver->id);
1352 if (card != RT_NULL)
1353 {
1354 return driver->probe(card);
1355 }
1356 }
1357
1358 return -RT_EEMPTY;
1359 }
1360
sdio_unregister_driver(struct rt_sdio_driver * driver)1361 rt_int32_t sdio_unregister_driver(struct rt_sdio_driver *driver)
1362 {
1363 rt_list_t *l;
1364 struct sdio_driver *sd = RT_NULL;
1365 struct rt_mmcsd_card *card;
1366
1367 for (l = (&sdio_drivers)->next; l != &sdio_drivers; l = l->next)
1368 {
1369 sd = (struct sdio_driver *)rt_list_entry(l, struct sdio_driver, list);
1370 if (sd->drv != driver)
1371 {
1372 sd = RT_NULL;
1373 }
1374 }
1375
1376 if (sd == RT_NULL)
1377 {
1378 LOG_E("SDIO driver %s not register", driver->name);
1379 return -RT_ERROR;
1380 }
1381
1382 if (!rt_list_isempty(&sdio_cards))
1383 {
1384 card = sdio_match_driver(driver->id);
1385 if (card != RT_NULL)
1386 {
1387 driver->remove(card);
1388 rt_list_remove(&sd->list);
1389 rt_free(sd);
1390 }
1391 }
1392
1393 return 0;
1394 }
1395
rt_sdio_init(void)1396 void rt_sdio_init(void)
1397 {
1398
1399 }
1400
1401