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