source: rtems/c/src/libchip/i2c/spi-sd-card.c @ 382f714

4.11
Last change on this file since 382f714 was 382f714, checked in by Pavel Pisa <ppisa@…>, on Oct 8, 2013 at 8:40:29 AM

SPI SD-Card: setup valid CRC-7 for STOP_TRANSMISSION command.

STOP_TRANSMISSION command is used to finish READ_MULTIPLE_BLOCK
command and its format is regular command format.
It requires valid CRC-7 to have effect at least on
same cards types else it is ignored and attempt
to issue next READ or WRITE commands results in
illegal command condition (0x04) preceded by strange
(0x3f) for tested card.

Signed-off-by: Pavel Pisa <ppisa@…>

  • Property mode set to 100644
File size: 37.5 KB
Line 
1/**
2 * @file
3 *
4 * @brief SD Card LibI2C driver.
5 */
6
7/*
8 * Copyright (c) 2008
9 * Embedded Brains GmbH
10 * Obere Lagerstr. 30
11 * D-82178 Puchheim
12 * Germany
13 * rtems@embedded-brains.de
14 *
15 * The license and distribution terms for this file may be
16 * found in the file LICENSE in this distribution or at
17 * http://www.rtems.com/license/LICENSE.
18 */
19
20#include <stdio.h>
21#include <string.h>
22#include <errno.h>
23#include <inttypes.h>
24
25#include <rtems.h>
26#include <rtems/libi2c.h>
27#include <rtems/libio.h>
28#include <rtems/diskdevs.h>
29#include <rtems/blkdev.h>
30
31#include <libchip/spi-sd-card.h>
32
33#include <rtems/status-checks.h>
34
35/**
36 * @name Integer to and from Byte-Stream Converter
37 * @{
38 */
39
40static inline uint16_t sd_card_get_uint16( const uint8_t *s)
41{
42        return (uint16_t) ((s [0] << 8) | s [1]);
43}
44
45static inline uint32_t sd_card_get_uint32( const uint8_t *s)
46{
47        return ((uint32_t) s [0] << 24) | ((uint32_t) s [1] << 16) | ((uint32_t) s [2] << 8) | (uint32_t) s [3];
48}
49
50static inline void sd_card_put_uint16( uint16_t v, uint8_t *s)
51{
52        *s++ = (uint8_t) (v >> 8);
53        *s   = (uint8_t) (v);
54}
55
56static inline void sd_card_put_uint32( uint32_t v, uint8_t *s)
57{
58        *s++ = (uint8_t) (v >> 24);
59        *s++ = (uint8_t) (v >> 16);
60        *s++ = (uint8_t) (v >> 8);
61        *s   = (uint8_t) (v);
62}
63
64/** @} */
65
66#define SD_CARD_BUSY_TOKEN 0
67
68#define SD_CARD_BLOCK_SIZE_DEFAULT 512
69
70#define SD_CARD_COMMAND_RESPONSE_START 7
71
72/**
73 * @name Commands
74 * @{
75 */
76
77#define SD_CARD_CMD_GO_IDLE_STATE 0
78#define SD_CARD_CMD_SEND_OP_COND 1
79#define SD_CARD_CMD_SEND_IF_COND 8
80#define SD_CARD_CMD_SEND_CSD 9
81#define SD_CARD_CMD_SEND_CID 10
82#define SD_CARD_CMD_STOP_TRANSMISSION 12
83#define SD_CARD_CMD_SEND_STATUS 13
84#define SD_CARD_CMD_SET_BLOCKLEN 16
85#define SD_CARD_CMD_READ_SINGLE_BLOCK 17
86#define SD_CARD_CMD_READ_MULTIPLE_BLOCK 18
87#define SD_CARD_CMD_SET_BLOCK_COUNT 23
88#define SD_CARD_CMD_WRITE_BLOCK 24
89#define SD_CARD_CMD_WRITE_MULTIPLE_BLOCK 25
90#define SD_CARD_CMD_PROGRAM_CSD 27
91#define SD_CARD_CMD_SET_WRITE_PROT 28
92#define SD_CARD_CMD_CLR_WRITE_PROT 29
93#define SD_CARD_CMD_SEND_WRITE_PROT 30
94#define SD_CARD_CMD_TAG_SECTOR_START 32
95#define SD_CARD_CMD_TAG_SECTOR_END 33
96#define SD_CARD_CMD_UNTAG_SECTOR 34
97#define SD_CARD_CMD_TAG_ERASE_GROUP_START 35
98#define SD_CARD_CMD_TAG_ERASE_GROUP_END 36
99#define SD_CARD_CMD_UNTAG_ERASE_GROUP 37
100#define SD_CARD_CMD_ERASE 38
101#define SD_CARD_CMD_LOCK_UNLOCK 42
102#define SD_CARD_CMD_APP_CMD 55
103#define SD_CARD_CMD_GEN_CND 56
104#define SD_CARD_CMD_READ_OCR 58
105#define SD_CARD_CMD_CRC_ON_OFF 59
106
107/** @} */
108
109/**
110 * @name Application Commands
111 * @{
112 */
113
114#define SD_CARD_ACMD_SD_SEND_OP_COND 41
115
116/** @} */
117
118/**
119 * @name Command Flags
120 * @{
121 */
122
123#define SD_CARD_FLAG_HCS 0x40000000U
124
125#define SD_CARD_FLAG_VHS_2_7_TO_3_3 0x00000100U
126
127#define SD_CARD_FLAG_CHECK_PATTERN 0x000000aaU
128
129/** @} */
130
131/**
132 * @name Command Fields
133 * @{
134 */
135
136#define SD_CARD_COMMAND_SET_COMMAND( c, cmd) (c) [1] = (uint8_t) (0x40 + ((cmd) & 0x3f))
137
138#define SD_CARD_COMMAND_SET_ARGUMENT( c, arg) sd_card_put_uint32( (arg), &((c) [2]))
139
140#define SD_CARD_COMMAND_SET_CRC7( c, crc7) ((c) [6] = ((crc7) << 1) | 1U)
141
142#define SD_CARD_COMMAND_GET_CRC7( c) ((c) [6] >> 1)
143
144/** @} */
145
146/**
147 * @name Response Fields
148 * @{
149 */
150
151#define SD_CARD_IS_RESPONSE( r) (((r) & 0x80) == 0)
152
153#define SD_CARD_IS_ERRORLESS_RESPONSE( r) (((r) & 0x7e) == 0)
154
155#define SD_CARD_IS_NOT_IDLE_RESPONSE( r) (((r) & 0x81) == 0)
156
157#define SD_CARD_IS_DATA_ERROR( r) (((r) & 0xe0) == 0)
158
159#define SD_CARD_IS_DATA_REJECTED( r) (((r) & 0x1f) != 0x05)
160
161/** @} */
162
163/**
164 * @name Card Identification
165 * @{
166 */
167
168#define SD_CARD_CID_SIZE 16
169
170#define SD_CARD_CID_GET_MID( cid) ((cid) [0])
171#define SD_CARD_CID_GET_OID( cid) sd_card_get_uint16( cid + 1)
172#define SD_CARD_CID_GET_PNM( cid, i) ((char) (cid) [3 + (i)])
173#define SD_CARD_CID_GET_PRV( cid) ((cid) [9])
174#define SD_CARD_CID_GET_PSN( cid) sd_card_get_uint32( cid + 10)
175#define SD_CARD_CID_GET_MDT( cid) ((cid) [14])
176#define SD_CARD_CID_GET_CRC7( cid) ((cid) [15] >> 1)
177
178/** @} */
179
180/**
181 * @name Card Specific Data
182 * @{
183 */
184
185#define SD_CARD_CSD_SIZE 16
186
187#define SD_CARD_CSD_GET_CSD_STRUCTURE( csd) ((csd) [0] >> 6)
188#define SD_CARD_CSD_GET_SPEC_VERS( csd) (((csd) [0] >> 2) & 0xf)
189#define SD_CARD_CSD_GET_TAAC( csd) ((csd) [1])
190#define SD_CARD_CSD_GET_NSAC( csd) ((uint32_t) (csd) [2])
191#define SD_CARD_CSD_GET_TRAN_SPEED( csd) ((csd) [3])
192#define SD_CARD_CSD_GET_C_SIZE( csd) ((((uint32_t) (csd) [6] & 0x3) << 10) + (((uint32_t) (csd) [7]) << 2) + ((((uint32_t) (csd) [8]) >> 6) & 0x3))
193#define SD_CARD_CSD_GET_C_SIZE_MULT( csd) ((((csd) [9] & 0x3) << 1) + (((csd) [10] >> 7) & 0x1))
194#define SD_CARD_CSD_GET_READ_BLK_LEN( csd) ((uint32_t) (csd) [5] & 0xf)
195#define SD_CARD_CSD_GET_WRITE_BLK_LEN( csd) ((((uint32_t) (csd) [12] & 0x3) << 2) + ((((uint32_t) (csd) [13]) >> 6) & 0x3))
196#define SD_CARD_CSD_1_GET_C_SIZE( csd) ((((uint32_t) (csd) [7] & 0x3f) << 16) + (((uint32_t) (csd) [8]) << 8) + (uint32_t) (csd) [9])
197
198/** @} */
199
200#define SD_CARD_INVALIDATE_RESPONSE_INDEX( e) e->response_index = SD_CARD_COMMAND_SIZE
201
202/**
203 * @name Data Start and Stop Tokens
204 * @{
205 */
206
207#define SD_CARD_START_BLOCK_SINGLE_BLOCK_READ 0xfe
208#define SD_CARD_START_BLOCK_MULTIPLE_BLOCK_READ 0xfe
209#define SD_CARD_START_BLOCK_SINGLE_BLOCK_WRITE 0xfe
210#define SD_CARD_START_BLOCK_MULTIPLE_BLOCK_WRITE 0xfc
211#define SD_CARD_STOP_TRANSFER_MULTIPLE_BLOCK_WRITE 0xfd
212
213/** @} */
214
215/**
216 * @name Card Specific Data Functions
217 * @{
218 */
219
220static inline uint32_t sd_card_block_number( const uint8_t *csd)
221{
222        uint32_t size = SD_CARD_CSD_GET_C_SIZE( csd);
223        uint32_t mult = 1U << (SD_CARD_CSD_GET_C_SIZE_MULT( csd) + 2);
224        return (size + 1) * mult;
225}
226
227static inline uint32_t sd_card_capacity( const uint8_t *csd)
228{
229        uint32_t block_size = 1U << SD_CARD_CSD_GET_READ_BLK_LEN( csd);
230        return sd_card_block_number( csd) * block_size;
231}
232
233static inline uint32_t sd_card_transfer_speed( const uint8_t *csd)
234{
235        uint32_t s = SD_CARD_CSD_GET_TRAN_SPEED( csd);
236        uint32_t e = s & 0x7;
237        uint32_t m = s >> 3;
238        switch (e) {
239                case 0: s = 10000; break;
240                case 1: s = 100000; break;
241                case 2: s = 1000000; break;
242                case 3: s = 10000000; break;
243                default: s = 0; break;
244        }
245        switch (m) {
246                case 1: s *= 10; break;
247                case 2: s *= 12; break;
248                case 3: s *= 13; break;
249                case 4: s *= 15; break;
250                case 5: s *= 20; break;
251                case 6: s *= 25; break;
252                case 7: s *= 30; break;
253                case 8: s *= 35; break;
254                case 9: s *= 40; break;
255                case 10: s *= 45; break;
256                case 11: s *= 50; break;
257                case 12: s *= 55; break;
258                case 13: s *= 60; break;
259                case 14: s *= 70; break;
260                case 15: s *= 80; break;
261                default: s *= 0; break;
262        }
263        return s;
264}
265
266static inline uint32_t sd_card_access_time( const uint8_t *csd)
267{
268        uint32_t ac = SD_CARD_CSD_GET_TAAC( csd);
269        uint32_t e = ac & 0x7;
270        uint32_t m = ac >> 3;
271        switch (e) {
272                case 0: ac = 1; break;
273                case 1: ac = 10; break;
274                case 2: ac = 100; break;
275                case 3: ac = 1000; break;
276                case 4: ac = 10000; break;
277                case 5: ac = 100000; break;
278                case 6: ac = 1000000; break;
279                case 7: ac = 10000000; break;
280                default: ac = 0; break;
281        }
282        switch (m) {
283                case 1: ac *= 10; break;
284                case 2: ac *= 12; break;
285                case 3: ac *= 13; break;
286                case 4: ac *= 15; break;
287                case 5: ac *= 20; break;
288                case 6: ac *= 25; break;
289                case 7: ac *= 30; break;
290                case 8: ac *= 35; break;
291                case 9: ac *= 40; break;
292                case 10: ac *= 45; break;
293                case 11: ac *= 50; break;
294                case 12: ac *= 55; break;
295                case 13: ac *= 60; break;
296                case 14: ac *= 70; break;
297                case 15: ac *= 80; break;
298                default: ac *= 0; break;
299        }
300        return ac / 10;
301}
302
303static inline uint32_t sd_card_max_access_time( const uint8_t *csd, uint32_t transfer_speed)
304{
305        uint64_t ac = sd_card_access_time( csd);
306        uint32_t ac_100ms = transfer_speed / 80;
307        uint32_t n = SD_CARD_CSD_GET_NSAC( csd) * 100;
308        /* ac is in ns, transfer_speed in bps, max_access_time in bytes.
309           max_access_time is 100 times typical access time (taac+nsac) */
310        ac = ac * transfer_speed / 80000000;
311        ac = ac + 100*n;
312        if ((uint32_t)ac > ac_100ms)
313                return ac_100ms;
314        else
315                return (uint32_t)ac;
316}
317
318/** @} */
319
320/**
321 * @name CRC functions
322 *
323 * Based on http://en.wikipedia.org/wiki/Computation_of_CRC
324 *
325 * @{
326 */
327
328static uint8_t sd_card_compute_crc7 (uint8_t *data, size_t len)
329{
330        uint8_t e, f, crc;
331        size_t i;
332
333        crc = 0;
334        for (i = 0; i < len; i++) {
335                e   = crc ^ data[i];
336                f   = e ^ (e >> 4) ^ (e >> 7);
337                crc = (f << 1) ^ (f << 4);
338        }
339        return crc >> 1;
340}
341
342static uint16_t sd_card_compute_crc16 (uint8_t *data, size_t len)
343{
344        uint8_t s, t;
345        uint16_t crc;
346        size_t i;
347
348        crc = 0;
349        for (i = 0; i < len; i++) {
350                s = data[i] ^ (crc >> 8);
351                t = s ^ (s >> 4);
352                crc = (crc << 8) ^ t ^ (t << 5) ^ (t << 12);
353        }
354        return crc;
355}
356
357/** @} */
358
359/**
360 * @name Communication Functions
361 * @{
362 */
363
364static inline int sd_card_query( sd_card_driver_entry *e, uint8_t *in, int n)
365{
366        return rtems_libi2c_read_bytes( e->bus, in, n);
367}
368
369static int sd_card_wait( sd_card_driver_entry *e)
370{
371        int rv = 0;
372        int r = 0;
373        int n = 2;
374        /* For writes, the timeout is 2.5 times that of reads; since we
375           don't know if it is a write or read, assume write.
376           FIXME should actually look at R2W_FACTOR for non-HC cards. */
377        int retries = e->n_ac_max * 25 / 10;
378        /* n_ac_max/100 is supposed to be the average waiting time. To
379           approximate this, we start with waiting n_ac_max/150 and
380           gradually increase the waiting time. */
381        int wait_time_bytes = (retries + 149) / 150;
382        while (e->busy) {
383                /* Query busy tokens */
384                rv = sd_card_query( e, e->response, n);
385                RTEMS_CHECK_RV( rv, "Busy");
386
387                /* Search for non busy tokens */
388                for (r = 0; r < n; ++r) {
389                        if (e->response [r] != SD_CARD_BUSY_TOKEN) {
390                                e->busy = false;
391                                return 0;
392                        }
393                }
394                retries -= n;
395                if (retries <= 0) {
396                        return -RTEMS_TIMEOUT;
397                }
398
399                if (e->schedule_if_busy) {
400                        uint64_t wait_time_us = wait_time_bytes;
401                        wait_time_us *= 8000000;
402                        wait_time_us /= e->transfer_mode.baudrate;
403                        rtems_task_wake_after( RTEMS_MICROSECONDS_TO_TICKS(wait_time_us));
404                        retries -= wait_time_bytes;
405                        wait_time_bytes = wait_time_bytes * 15 / 10;
406                } else {
407                        n = SD_CARD_COMMAND_SIZE;
408                }
409        }
410        return 0;
411}
412
413static int sd_card_send_command( sd_card_driver_entry *e, uint32_t command, uint32_t argument)
414{
415        int rv = 0;
416        rtems_libi2c_read_write_t rw = {
417                .rd_buf = e->response,
418                .wr_buf = e->command,
419                .byte_cnt = SD_CARD_COMMAND_SIZE
420        };
421        int r = 0;
422        uint8_t crc7;
423
424        SD_CARD_INVALIDATE_RESPONSE_INDEX( e);
425
426        /* Wait until card is not busy */
427        rv = sd_card_wait( e);
428        RTEMS_CHECK_RV( rv, "Wait");
429
430        /* Write command and read response */
431        SD_CARD_COMMAND_SET_COMMAND( e->command, command);
432        SD_CARD_COMMAND_SET_ARGUMENT( e->command, argument);
433        crc7 = sd_card_compute_crc7( e->command + 1, 5);
434        SD_CARD_COMMAND_SET_CRC7( e->command, crc7);
435        rv = rtems_libi2c_ioctl( e->bus, RTEMS_LIBI2C_IOCTL_READ_WRITE, &rw);
436        RTEMS_CHECK_RV( rv, "Write command and read response");
437
438        /* Check respose */
439        for (r = SD_CARD_COMMAND_RESPONSE_START; r < SD_CARD_COMMAND_SIZE; ++r) {
440                RTEMS_DEBUG_PRINT( "Token [%02u]: 0x%02x\n", r, e->response [r]);
441                e->response_index = r;
442                if (SD_CARD_IS_RESPONSE( e->response [r])) {
443                        if (SD_CARD_IS_ERRORLESS_RESPONSE( e->response [r])) {
444                                return 0;
445                        } else {
446                                RTEMS_SYSLOG_ERROR( "Command error [%02i]: 0x%02" PRIx8 "\n", r, e->response [r]);
447                                goto sd_card_send_command_error;
448                        }
449                } else if (e->response [r] != SD_CARD_IDLE_TOKEN) {
450                        RTEMS_SYSLOG_ERROR( "Unexpected token [%02i]: 0x%02" PRIx8 "\n", r, e->response [r]);
451                        goto sd_card_send_command_error;
452                }
453        }
454
455        RTEMS_SYSLOG_ERROR( "Timeout\n");
456
457sd_card_send_command_error:
458
459        RTEMS_SYSLOG_ERROR( "Response:");
460        for (r = 0; r < SD_CARD_COMMAND_SIZE; ++r) {
461                if (e->response_index == r) {
462                        RTEMS_SYSLOG_PRINT( " %02" PRIx8 ":[%02" PRIx8 "]", e->command [r], e->response [r]);
463                } else {
464                        RTEMS_SYSLOG_PRINT( " %02" PRIx8 ":%02" PRIx8 "", e->command [r], e->response [r]);
465                }
466        }
467        RTEMS_SYSLOG_PRINT( "\n");
468
469        return -RTEMS_IO_ERROR;
470}
471
472static int sd_card_send_register_command( sd_card_driver_entry *e, uint32_t command, uint32_t argument, uint32_t *reg)
473{
474        int rv = 0;
475        uint8_t crc7;
476
477        rv = sd_card_send_command( e, command, argument);
478        RTEMS_CHECK_RV( rv, "Send command");
479
480        if (e->response_index + 5 > SD_CARD_COMMAND_SIZE) {
481                /*
482                 * TODO: If this happens in the wild we need to implement a
483                 * more sophisticated response query.
484                 */
485                RTEMS_SYSLOG_ERROR( "Unexpected response position\n");
486                return -RTEMS_IO_ERROR;
487        }
488
489        crc7 = sd_card_compute_crc7( e->response + e->response_index, 5);
490        if (crc7 != SD_CARD_COMMAND_GET_CRC7( e->response + e->response_index) &&
491                SD_CARD_COMMAND_GET_CRC7( e->response + e->response_index) != 0x7f) {
492                RTEMS_SYSLOG_ERROR( "CRC check failed on register command\n");
493                return -RTEMS_IO_ERROR;
494        }
495
496        *reg = sd_card_get_uint32( e->response + e->response_index + 1);
497
498        return 0;
499}
500
501static int sd_card_stop_multiple_block_read( sd_card_driver_entry *e)
502{
503        int rv = 0;
504        uint8_t crc7;
505
506        SD_CARD_COMMAND_SET_COMMAND( e->command, SD_CARD_CMD_STOP_TRANSMISSION);
507        SD_CARD_COMMAND_SET_ARGUMENT( e->command, 0);
508        /*crc7 = sd_card_compute_crc7( e->command + 1, 5);*/
509        crc7 = 0x30;    /* Help compiler - command and argument are constants */
510        SD_CARD_COMMAND_SET_CRC7( e->command, crc7);
511        rv = rtems_libi2c_write_bytes( e->bus, e->command, SD_CARD_COMMAND_SIZE);
512        RTEMS_CHECK_RV( rv, "Write stop transfer token");
513
514        return 0;
515}
516
517static int sd_card_stop_multiple_block_write( sd_card_driver_entry *e)
518{
519        int rv = 0;
520        uint8_t stop_transfer [3] = { SD_CARD_IDLE_TOKEN, SD_CARD_STOP_TRANSFER_MULTIPLE_BLOCK_WRITE, SD_CARD_IDLE_TOKEN };
521
522        /* Wait until card is not busy */
523        rv = sd_card_wait( e);
524        RTEMS_CHECK_RV( rv, "Wait");
525
526        /* Send stop token */
527        rv = rtems_libi2c_write_bytes( e->bus, stop_transfer, 3);
528        RTEMS_CHECK_RV( rv, "Write stop transfer token");
529
530        /* Card is now busy */
531        e->busy = true;
532
533        return 0;
534}
535
536static int sd_card_read( sd_card_driver_entry *e, uint8_t start_token, uint8_t *in, int n)
537{
538        int rv = 0;
539
540        /* Discard command response */
541        int r = e->response_index + 1;
542
543        /* Standard response size */
544        int response_size = SD_CARD_COMMAND_SIZE;
545
546        /* Where the response is stored */
547        uint8_t *response = e->response;
548
549        /* Data input index */
550        int i = 0;
551
552        /* CRC check of data */
553        uint16_t crc16;
554
555        /* Maximum number of tokens to read. */
556        int retries = e->n_ac_max;
557
558        SD_CARD_INVALIDATE_RESPONSE_INDEX( e);
559
560        while (true) {
561                RTEMS_DEBUG_PRINT( "Search from %u to %u\n", r, response_size - 1);
562
563                /* Search the data start token in in current response buffer */
564                retries -= (response_size - r);
565                while (r < response_size) {
566                        RTEMS_DEBUG_PRINT( "Token [%02u]: 0x%02x\n", r, response [r]);
567                        if (response [r] == start_token) {
568                                /* Discard data start token */
569                                ++r;
570                                goto sd_card_read_start;
571                        } else if (SD_CARD_IS_DATA_ERROR( response [r])) {
572                                RTEMS_SYSLOG_ERROR( "Data error token [%02i]: 0x%02" PRIx8 "\n", r, response [r]);
573                                return -RTEMS_IO_ERROR;
574                        } else if (response [r] != SD_CARD_IDLE_TOKEN) {
575                                RTEMS_SYSLOG_ERROR( "Unexpected token [%02i]: 0x%02" PRIx8 "\n", r, response [r]);
576                                return -RTEMS_IO_ERROR;
577                        }
578                        ++r;
579                }
580
581                if (retries <= 0) {
582                        RTEMS_SYSLOG_ERROR( "Timeout\n");
583                        return -RTEMS_IO_ERROR;
584                }
585
586                if (e->schedule_if_busy)
587                        rtems_task_wake_after( RTEMS_YIELD_PROCESSOR);
588
589                /* Query more.  We typically have to wait between 10 and 100
590                   bytes.  To reduce overhead, read the response in chunks of
591                   50 bytes - this doesn't introduce too much copy overhead
592                   but does allow SPI DMA transfers to work efficiently. */
593                response = in;
594                response_size = 50;
595                if (response_size > n)
596                        response_size = n;
597                rv = sd_card_query( e, response, response_size);
598                RTEMS_CHECK_RV( rv, "Query data start token");
599
600                /* Reset start position */
601                r = 0;
602        }
603
604sd_card_read_start:
605
606        /* Read data */
607        while (r < response_size && i < n) {
608                in [i++] = response [r++];
609        }
610
611        /* Read more data? */
612        if (i < n) {
613                rv = sd_card_query( e, &in [i], n - i);
614                RTEMS_CHECK_RV( rv, "Read data");
615                i += rv;
616        }
617
618        /* Read CRC 16 and N_RC */
619        rv = sd_card_query( e, e->response, 3);
620        RTEMS_CHECK_RV( rv, "Read CRC 16");
621
622        crc16 = sd_card_compute_crc16 (in, n);
623        if ((e->response[0] != ((crc16 >> 8) & 0xff)) ||
624            (e->response[1] != (crc16 & 0xff))) {
625                RTEMS_SYSLOG_ERROR( "CRC check failed on read\n");
626                return -RTEMS_IO_ERROR;
627        }
628
629        return i;
630}
631
632static int sd_card_write( sd_card_driver_entry *e, uint8_t start_token, uint8_t *out, int n)
633{
634        int rv = 0;
635        uint8_t crc16_bytes [2] = { 0, 0 };
636        uint16_t crc16;
637
638        /* Data output index */
639        int o = 0;
640
641        /* Wait until card is not busy */
642        rv = sd_card_wait( e);
643        RTEMS_CHECK_RV( rv, "Wait");
644
645        /* Write data start token */
646        rv = rtems_libi2c_write_bytes( e->bus, &start_token, 1);
647        RTEMS_CHECK_RV( rv, "Write data start token");
648
649        /* Write data */
650        o = rtems_libi2c_write_bytes( e->bus, out, n);
651        RTEMS_CHECK_RV( o, "Write data");
652
653        /* Write CRC 16 */
654        crc16 = sd_card_compute_crc16(out, n);
655        crc16_bytes[0] = (crc16>>8) & 0xff;
656        crc16_bytes[1] = (crc16) & 0xff;
657        rv = rtems_libi2c_write_bytes( e->bus, crc16_bytes, 2);
658        RTEMS_CHECK_RV( rv, "Write CRC 16");
659
660        /* Read data response */
661        rv = sd_card_query( e, e->response, 2);
662        RTEMS_CHECK_RV( rv, "Read data response");
663        if (SD_CARD_IS_DATA_REJECTED( e->response [0])) {
664                RTEMS_SYSLOG_ERROR( "Data rejected: 0x%02" PRIx8 "\n", e->response [0]);
665                return -RTEMS_IO_ERROR;
666        }
667
668        /* Card is now busy */
669        e->busy = true;
670
671        return o;
672}
673
674static inline rtems_status_code sd_card_start( sd_card_driver_entry *e)
675{
676        rtems_status_code sc = RTEMS_SUCCESSFUL;
677        int rv = 0;
678
679        sc = rtems_libi2c_send_start( e->bus);
680        RTEMS_CHECK_SC( sc, "Send start");
681
682        rv = rtems_libi2c_ioctl( e->bus, RTEMS_LIBI2C_IOCTL_SET_TFRMODE, &e->transfer_mode);
683        RTEMS_CHECK_RV_SC( rv, "Set transfer mode");
684
685        sc = rtems_libi2c_send_addr( e->bus, 1);
686        RTEMS_CHECK_SC( sc, "Send address");
687
688        return RTEMS_SUCCESSFUL;
689}
690
691static inline rtems_status_code sd_card_stop( sd_card_driver_entry *e)
692{
693        rtems_status_code sc = RTEMS_SUCCESSFUL;
694
695        sc = rtems_libi2c_send_stop( e->bus);
696        RTEMS_CHECK_SC( sc, "Send stop");
697
698        return RTEMS_SUCCESSFUL;
699}
700
701static rtems_status_code sd_card_init( sd_card_driver_entry *e)
702{
703        rtems_status_code sc = RTEMS_SUCCESSFUL;
704        int rv = 0;
705        uint8_t block [SD_CARD_BLOCK_SIZE_DEFAULT];
706        uint32_t transfer_speed = 0;
707        uint32_t read_block_size = 0;
708        uint32_t write_block_size = 0;
709        uint8_t csd_structure = 0;
710        uint64_t capacity = 0;
711        uint8_t crc7;
712
713        /* Assume first that we have a SD card and not a MMC card */
714        bool assume_sd = true;
715
716        /*
717         * Assume high capacity until proven wrong (applies to SD and not yet
718         * existing MMC).
719         */
720        bool high_capacity = true;
721
722        bool do_cmd58 = true;
723        uint32_t cmd_arg = 0;
724        uint32_t if_cond_test = SD_CARD_FLAG_VHS_2_7_TO_3_3 | SD_CARD_FLAG_CHECK_PATTERN;
725        uint32_t if_cond_reg = if_cond_test;
726
727        /* Start */
728        sc = sd_card_start( e);
729        RTEMS_CLEANUP_SC( sc, sd_card_driver_init_cleanup, "Start");
730
731        /* Wait until card is not busy */
732        rv = sd_card_wait( e);
733        RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Wait");
734
735        /* Send idle tokens for at least 74 clock cycles with active chip select */
736        memset( block, SD_CARD_IDLE_TOKEN, SD_CARD_BLOCK_SIZE_DEFAULT);
737        rv = rtems_libi2c_write_bytes( e->bus, block, SD_CARD_BLOCK_SIZE_DEFAULT);
738        RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Active chip select delay");
739
740        /* Stop */
741        sc = sd_card_stop( e);
742        RTEMS_CHECK_SC( sc, "Stop");
743
744        /* Start with inactive chip select */
745        sc = rtems_libi2c_send_start( e->bus);
746        RTEMS_CHECK_SC( sc, "Send start");
747
748        /* Set transfer mode */
749        rv = rtems_libi2c_ioctl( e->bus, RTEMS_LIBI2C_IOCTL_SET_TFRMODE, &e->transfer_mode);
750        RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Set transfer mode");
751
752        /* Send idle tokens with inactive chip select */
753        rv = sd_card_query( e, e->response, SD_CARD_COMMAND_SIZE);
754        RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Inactive chip select delay");
755
756        /* Activate chip select */
757        sc = rtems_libi2c_send_addr( e->bus, 1);
758        RTEMS_CLEANUP_SC( sc, sd_card_driver_init_cleanup, "Send address");
759
760        /* Stop multiple block write */
761        sd_card_stop_multiple_block_write( e);
762
763        /* Get card status */
764        sd_card_send_command( e, SD_CARD_CMD_SEND_STATUS, 0);
765
766        /* Stop multiple block read */
767        sd_card_stop_multiple_block_read( e);
768
769        /* Switch to SPI mode */
770        rv = sd_card_send_command( e, SD_CARD_CMD_GO_IDLE_STATE, 0);
771        RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Send: SD_CARD_CMD_GO_IDLE_STATE");
772
773        /*
774         * Get interface condition, CMD8.  This is new for SD 2.x and enables
775         * getting the High Capacity Support flag HCS and checks that the
776         * voltage is right.  Some MMCs accept this command but will still fail
777         * on ACMD41.  SD 1.x cards will fails this command and do not support
778         * HCS (> 2G capacity).
779         */
780        rv = sd_card_send_register_command( e, SD_CARD_CMD_SEND_IF_COND, if_cond_reg, &if_cond_reg);
781
782        /*
783         * Regardless of whether CMD8 above passes or fails, send ACMD41.  If
784         * card is MMC it will fail.  But older SD < 2.0 (which fail CMD8) will
785         * always stay "idle" if cmd_arg is non-zero, so set to 0 above on
786         * fail.
787         */
788        if (rv < 0) {
789                /* Failed CMD8, so SD 1.x or MMC */
790                cmd_arg = 0;
791        } else {
792                cmd_arg = SD_CARD_FLAG_HCS;
793        }
794
795        /* Enable CRC */
796        sd_card_send_command( e, SD_CARD_CMD_CRC_ON_OFF, 1);
797
798        /* Initialize card */
799        while (true) {
800                if (assume_sd) {
801                        /* This command (CMD55) supported by SD and (most?) MMCs */
802                        rv = sd_card_send_command( e, SD_CARD_CMD_APP_CMD, 0);
803                        if (rv < 0) {
804                                RTEMS_SYSLOG( "CMD55 failed.  Assume MMC and try CMD1\n");
805                                assume_sd = false;
806                                continue;
807                        }
808
809                        /*
810                         * This command (ACMD41) only supported by SD.  Always
811                         * fails if MMC.
812                         */
813                        rv = sd_card_send_command( e, SD_CARD_ACMD_SD_SEND_OP_COND, cmd_arg);
814                        if (rv < 0) {
815                                /*
816                                 * This *will* fail for MMC.  If fails, bad/no
817                                 * card or card is MMC, do CMD58 then CMD1.
818                                 */
819                                RTEMS_SYSLOG( "ACMD41 failed.  Assume MMC and do CMD58 (once) then CMD1\n");
820                                assume_sd = false;
821                                cmd_arg = SD_CARD_FLAG_HCS;
822                                do_cmd58 = true;
823                                continue;
824                        } else {
825                                /*
826                                 * Passed ACMD41 so SD.  It is now save to
827                                 * check if_cond_reg from CMD8.  Reject the
828                                 * card in case of a indicated bad voltage.
829                                 */
830                                if (if_cond_reg != if_cond_test) {
831                                        RTEMS_CLEANUP_RV_SC( -1, sc, sd_card_driver_init_cleanup, "Bad voltage for SD");
832                                }
833                        }
834                } else {
835                        /*
836                         * Does not seem to be SD card.  Do init for MMC.
837                         * First send CMD58 once to enable check for HCS
838                         * (similar to CMD8 of SD) with bits 30:29 set to 10b.
839                         * This will work for MMC >= 4.2.  Older cards (<= 4.1)
840                         * may may not respond to CMD1 unless CMD58 is sent
841                         * again with zero argument.
842                         */
843                        if (do_cmd58) {
844                                rv = sd_card_send_command( e, SD_CARD_CMD_READ_OCR, cmd_arg);
845                                RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Failed CMD58 for MMC");
846
847                                /* A one-shot call */
848                                do_cmd58 = false;
849                        }
850
851                        /* Do CMD1 */
852                        rv = sd_card_send_command( e, SD_CARD_CMD_SEND_OP_COND, 0);
853                        if (rv < 0) {
854                                if (cmd_arg != 0) {
855                                        /*
856                                         * Send CMD58 again with zero argument
857                                         * value.  Proves card is not
858                                         * high_capacity.
859                                         */
860                                        cmd_arg = 0;
861                                        do_cmd58 = true;
862                                        high_capacity = false;
863                                        continue;
864                                }
865
866                                RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Failed to initialize MMC");
867                        }
868                }
869
870                /*
871                 * Not idle?
872                 *
873                 * This hangs forever if the card remains not idle and sends
874                 * always a valid response.
875                 */
876                if (SD_CARD_IS_NOT_IDLE_RESPONSE( e->response [e->response_index])) {
877                        break;
878                }
879
880                /* Invoke the scheduler */
881                rtems_task_wake_after( RTEMS_YIELD_PROCESSOR);
882        }
883
884        /* Now we know if we are SD or MMC */
885        if (assume_sd) {
886                if (cmd_arg == 0) {
887                        /* SD is < 2.0 so never high capacity (<= 2G) */
888                        high_capacity = 0;
889                } else {
890                        uint32_t reg = 0;
891
892                        /*
893                         * SD is definitely 2.x.  Now need to send CMD58 to get
894                         * the OCR to see if the HCS bit is set (capacity > 2G)
895                         * or if bit is off (capacity <= 2G, standard
896                         * capacity).
897                         */
898                        rv = sd_card_send_register_command( e, SD_CARD_CMD_READ_OCR, 0, &reg);
899                        RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Failed CMD58 for SD 2.x");
900
901                        /* Check HCS bit of OCR */
902                        high_capacity = (reg & SD_CARD_FLAG_HCS) != 0;
903                }
904        } else {
905                /*
906                 * Card is MMC.  Unless already proven to be not HCS (< 4.2)
907                 * must do CMD58 again to check the OCR bits 30:29.
908                 */
909                if (high_capacity) {
910                        uint32_t reg = 0;
911
912                        /*
913                         * The argument should still be correct since was never
914                         * set to 0
915                         */
916                        rv = sd_card_send_register_command( e, SD_CARD_CMD_READ_OCR, cmd_arg, &reg);
917                        RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Failed CMD58 for MMC 4.2");
918
919                        /* Check HCS bit of the OCR */
920                        high_capacity = (reg & 0x600000) == SD_CARD_FLAG_HCS;
921                }
922        }
923
924        /* Card Identification */
925        if (e->verbose) {
926                rv = sd_card_send_command( e, SD_CARD_CMD_SEND_CID, 0);
927                RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Send: SD_CARD_CMD_SEND_CID");
928                rv = sd_card_read( e, SD_CARD_START_BLOCK_SINGLE_BLOCK_READ, block, SD_CARD_CID_SIZE);
929                RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Read: SD_CARD_CMD_SEND_CID");
930                RTEMS_SYSLOG( "*** Card Identification ***\n");
931                RTEMS_SYSLOG( "Manufacturer ID          : %" PRIu8 "\n", SD_CARD_CID_GET_MID( block));
932                RTEMS_SYSLOG( "OEM/Application ID       : %" PRIu16 "\n", SD_CARD_CID_GET_OID( block));
933                RTEMS_SYSLOG(
934                        "Product name             : %c%c%c%c%c%c\n",
935                        SD_CARD_CID_GET_PNM( block, 0),
936                        SD_CARD_CID_GET_PNM( block, 1),
937                        SD_CARD_CID_GET_PNM( block, 2),
938                        SD_CARD_CID_GET_PNM( block, 3),
939                        SD_CARD_CID_GET_PNM( block, 4),
940                        SD_CARD_CID_GET_PNM( block, 5)
941                );
942                RTEMS_SYSLOG( "Product revision         : %" PRIu8 "\n", SD_CARD_CID_GET_PRV( block));
943                RTEMS_SYSLOG( "Product serial number    : %" PRIu32 "\n", SD_CARD_CID_GET_PSN( block));
944                RTEMS_SYSLOG( "Manufacturing date       : %" PRIu8 "\n", SD_CARD_CID_GET_MDT( block));
945                RTEMS_SYSLOG( "7-bit CRC checksum       : %" PRIu8 "\n",  SD_CARD_CID_GET_CRC7( block));
946                crc7 = sd_card_compute_crc7( block, 15);
947                if (crc7 != SD_CARD_CID_GET_CRC7( block))
948                        RTEMS_SYSLOG( "  Failed! (computed %02" PRIx8 ")\n", crc7);
949        }
950
951        /* Card Specific Data */
952
953        /* Read CSD */
954        rv = sd_card_send_command( e, SD_CARD_CMD_SEND_CSD, 0);
955        RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Send: SD_CARD_CMD_SEND_CSD");
956        rv = sd_card_read( e, SD_CARD_START_BLOCK_SINGLE_BLOCK_READ, block, SD_CARD_CSD_SIZE);
957        RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Read: SD_CARD_CMD_SEND_CSD");
958
959        crc7 = sd_card_compute_crc7( block, 15);
960        if (crc7 != SD_CARD_CID_GET_CRC7( block)) {
961                RTEMS_SYSLOG( "SD_CARD_CMD_SEND_CSD CRC failed\n");
962                sc = RTEMS_IO_ERROR;
963                goto sd_card_driver_init_cleanup;
964        }
965       
966        /* CSD Structure */
967        csd_structure = SD_CARD_CSD_GET_CSD_STRUCTURE( block);
968
969        /* Transfer speed and access time */
970        transfer_speed = sd_card_transfer_speed( block);
971        e->transfer_mode.baudrate = transfer_speed;
972        e->n_ac_max = sd_card_max_access_time( block, transfer_speed);
973
974        /* Block sizes and capacity */
975        if (csd_structure == 0 || !assume_sd) {
976                /* Treat MMC same as CSD Version 1.0 */
977
978                read_block_size = 1U << SD_CARD_CSD_GET_READ_BLK_LEN( block);
979                e->block_size_shift = SD_CARD_CSD_GET_WRITE_BLK_LEN( block);
980                write_block_size = 1U << e->block_size_shift;
981                if (read_block_size < write_block_size) {
982                        RTEMS_SYSLOG_ERROR( "Read block size smaller than write block size\n");
983                        return -RTEMS_IO_ERROR;
984                }
985                e->block_size = write_block_size;
986                e->block_number = sd_card_block_number( block);
987                capacity = sd_card_capacity( block);
988        } else if (csd_structure == 1) {
989                uint32_t c_size = SD_CARD_CSD_1_GET_C_SIZE( block);
990
991                /* Block size is fixed in CSD Version 2.0 */
992                e->block_size_shift = 9;
993                e->block_size = 512;
994
995                e->block_number = (c_size + 1) * 1024;
996                capacity = (c_size + 1) * 512 * 1024;
997                read_block_size = 512;
998                write_block_size = 512;
999
1000                /* Timeout is fixed at 100ms in CSD Version 2.0 */
1001                e->n_ac_max = transfer_speed / 80;
1002        } else {
1003                RTEMS_DO_CLEANUP_SC( RTEMS_IO_ERROR, sc, sd_card_driver_init_cleanup, "Unexpected CSD Structure number");
1004        }
1005
1006        /* Print CSD information */
1007        if (e->verbose) {
1008                RTEMS_SYSLOG( "*** Card Specific Data ***\n");
1009                RTEMS_SYSLOG( "CSD structure            : %" PRIu8 "\n", SD_CARD_CSD_GET_CSD_STRUCTURE( block));
1010                RTEMS_SYSLOG( "Spec version             : %" PRIu8 "\n", SD_CARD_CSD_GET_SPEC_VERS( block));
1011                RTEMS_SYSLOG( "Access time [ns]         : %" PRIu32 "\n", sd_card_access_time( block));
1012                RTEMS_SYSLOG( "Access time [N]          : %" PRIu32 "\n", SD_CARD_CSD_GET_NSAC( block)*100);
1013                RTEMS_SYSLOG( "Max access time [N]      : %" PRIu32 "\n", e->n_ac_max);
1014                RTEMS_SYSLOG( "Max read block size [B]  : %" PRIu32 "\n", read_block_size);
1015                RTEMS_SYSLOG( "Max write block size [B] : %" PRIu32 "\n", write_block_size);
1016                RTEMS_SYSLOG( "Block size [B]           : %" PRIu32 "\n", e->block_size);
1017                RTEMS_SYSLOG( "Block number             : %" PRIu32 "\n", e->block_number);
1018                RTEMS_SYSLOG( "Capacity [B]             : %" PRIu64 "\n", capacity);
1019                RTEMS_SYSLOG( "Max transfer speed [b/s] : %" PRIu32 "\n", transfer_speed);
1020        }
1021
1022        if (high_capacity) {
1023                /* For high capacity cards the address is in blocks */
1024                e->block_size_shift = 0;
1025        } else if (e->block_size_shift == 10) {
1026                /*
1027                 * Low capacity 2GByte cards with reported block size of 1024
1028                 * need to be set back to block size of 512 per 'Simplified
1029                 * Physical Layer Specification Version 2.0' section 4.3.2.
1030                 * Otherwise, CMD16 fails if set to 1024.
1031                 */
1032                e->block_size_shift = 9;
1033                e->block_size = 512;
1034                e->block_number *= 2;
1035        }
1036
1037        /* Set read block size */
1038        rv = sd_card_send_command( e, SD_CARD_CMD_SET_BLOCKLEN, e->block_size);
1039        RTEMS_CLEANUP_RV_SC( rv, sc, sd_card_driver_init_cleanup, "Send: SD_CARD_CMD_SET_BLOCKLEN");
1040
1041        /* Stop */
1042        sc = sd_card_stop( e);
1043        RTEMS_CHECK_SC( sc, "Stop");
1044
1045        return RTEMS_SUCCESSFUL;
1046
1047sd_card_driver_init_cleanup:
1048
1049        /* Stop */
1050        sd_card_stop( e);
1051
1052        return sc;
1053}
1054/** @} */
1055
1056/**
1057 * @name Disk Driver Functions
1058 * @{
1059 */
1060
1061static int sd_card_disk_block_read( sd_card_driver_entry *e, rtems_blkdev_request *r)
1062{
1063        rtems_status_code sc = RTEMS_SUCCESSFUL;
1064        int rv = 0;
1065        uint32_t start_address = RTEMS_BLKDEV_START_BLOCK (r) << e->block_size_shift;
1066        uint32_t i = 0;
1067
1068#ifdef DEBUG
1069        /* Check request */
1070        if (r->bufs[0].block >= e->block_number) {
1071                RTEMS_SYSLOG_ERROR( "Start block number out of range");
1072                return -RTEMS_INTERNAL_ERROR;
1073        } else if (r->bufnum > e->block_number - RTEMS_BLKDEV_START_BLOCK (r)) {
1074                RTEMS_SYSLOG_ERROR( "Block count out of range");
1075                return -RTEMS_INTERNAL_ERROR;
1076        }
1077#endif /* DEBUG */
1078
1079        /* Start */
1080        sc = sd_card_start( e);
1081        RTEMS_CLEANUP_SC_RV( sc, rv, sd_card_disk_block_read_cleanup, "Start");
1082
1083        if (r->bufnum == 1) {
1084#ifdef DEBUG
1085                /* Check buffer */
1086                if (r->bufs [0].length != e->block_size) {
1087                        RTEMS_DO_CLEANUP_RV( -RTEMS_INTERNAL_ERROR, rv, sd_card_disk_block_read_cleanup, "Buffer and disk block size are not equal");
1088                }
1089                RTEMS_DEBUG_PRINT( "[01:01]: buffer = 0x%08x, size = %u\n", r->bufs [0].buffer, r->bufs [0].length);
1090#endif /* DEBUG */
1091
1092                /* Single block read */
1093                rv = sd_card_send_command( e, SD_CARD_CMD_READ_SINGLE_BLOCK, start_address);
1094                RTEMS_CLEANUP_RV( rv, sd_card_disk_block_read_cleanup, "Send: SD_CARD_CMD_READ_SINGLE_BLOCK");
1095                rv = sd_card_read( e, SD_CARD_START_BLOCK_SINGLE_BLOCK_READ, (uint8_t *) r->bufs [0].buffer, (int) e->block_size);
1096                RTEMS_CLEANUP_RV( rv, sd_card_disk_block_read_cleanup, "Read: SD_CARD_CMD_READ_SINGLE_BLOCK");
1097        } else {
1098                /* Start multiple block read */
1099                rv = sd_card_send_command( e, SD_CARD_CMD_READ_MULTIPLE_BLOCK, start_address);
1100                RTEMS_CLEANUP_RV( rv, sd_card_disk_block_read_stop_cleanup, "Send: SD_CARD_CMD_READ_MULTIPLE_BLOCK");
1101
1102                /* Multiple block read */
1103                for (i = 0; i < r->bufnum; ++i) {
1104#ifdef DEBUG
1105                        /* Check buffer */
1106                        if (r->bufs [i].length != e->block_size) {
1107                                RTEMS_DO_CLEANUP_RV( -RTEMS_INTERNAL_ERROR, rv, sd_card_disk_block_read_stop_cleanup, "Buffer and disk block size are not equal");
1108                        }
1109                        RTEMS_DEBUG_PRINT( "[%02u:%02u]: buffer = 0x%08x, size = %u\n", i + 1, r->bufnum, r->bufs [i].buffer, r->bufs [i].length);
1110#endif /* DEBUG */
1111
1112                        rv = sd_card_read( e, SD_CARD_START_BLOCK_MULTIPLE_BLOCK_READ, (uint8_t *) r->bufs [i].buffer, (int) e->block_size);
1113                        RTEMS_CLEANUP_RV( rv, sd_card_disk_block_read_stop_cleanup, "Read block");
1114                }
1115
1116                /* Stop multiple block read */
1117                rv = sd_card_stop_multiple_block_read( e);
1118                RTEMS_CLEANUP_RV( rv, sd_card_disk_block_read_cleanup, "Stop multiple block read");
1119        }
1120
1121        /* Stop */
1122        sc = sd_card_stop( e);
1123        RTEMS_CHECK_SC_RV( sc, "Stop");
1124
1125        /* Done */
1126        rtems_blkdev_request_done( r, RTEMS_SUCCESSFUL);
1127
1128        return 0;
1129
1130sd_card_disk_block_read_stop_cleanup:
1131
1132        /* Stop multiple block read */
1133        sd_card_stop_multiple_block_read( e);
1134
1135sd_card_disk_block_read_cleanup:
1136
1137        /* Stop */
1138        sd_card_stop( e);
1139
1140        /* Done */
1141        rtems_blkdev_request_done( r, RTEMS_IO_ERROR);
1142
1143        return 0;
1144}
1145
1146static int sd_card_disk_block_write( sd_card_driver_entry *e, rtems_blkdev_request *r)
1147{
1148        rtems_status_code sc = RTEMS_SUCCESSFUL;
1149        int rv = 0;
1150        uint32_t start_address = RTEMS_BLKDEV_START_BLOCK (r) << e->block_size_shift;
1151        uint32_t i = 0;
1152
1153#ifdef DEBUG
1154        /* Check request */
1155        if (r->bufs[0].block >= e->block_number) {
1156                RTEMS_SYSLOG_ERROR( "Start block number out of range");
1157                return -RTEMS_INTERNAL_ERROR;
1158        } else if (r->bufnum > e->block_number - RTEMS_BLKDEV_START_BLOCK (r)) {
1159                RTEMS_SYSLOG_ERROR( "Block count out of range");
1160                return -RTEMS_INTERNAL_ERROR;
1161        }
1162#endif /* DEBUG */
1163
1164        /* Start */
1165        sc = sd_card_start( e);
1166        RTEMS_CLEANUP_SC_RV( sc, rv, sd_card_disk_block_write_cleanup, "Start");
1167
1168        if (r->bufnum == 1) {
1169#ifdef DEBUG
1170                /* Check buffer */
1171                if (r->bufs [0].length != e->block_size) {
1172                        RTEMS_DO_CLEANUP_RV( -RTEMS_INTERNAL_ERROR, rv, sd_card_disk_block_write_cleanup, "Buffer and disk block size are not equal");
1173                }
1174                RTEMS_DEBUG_PRINT( "[01:01]: buffer = 0x%08x, size = %u\n", r->bufs [0].buffer, r->bufs [0].length);
1175#endif /* DEBUG */
1176
1177                /* Single block write */
1178                rv = sd_card_send_command( e, SD_CARD_CMD_WRITE_BLOCK, start_address);
1179                RTEMS_CLEANUP_RV( rv, sd_card_disk_block_write_cleanup, "Send: SD_CARD_CMD_WRITE_BLOCK");
1180                rv = sd_card_write( e, SD_CARD_START_BLOCK_SINGLE_BLOCK_WRITE, (uint8_t *) r->bufs [0].buffer, (int) e->block_size);
1181                RTEMS_CLEANUP_RV( rv, sd_card_disk_block_write_cleanup, "Write: SD_CARD_CMD_WRITE_BLOCK");
1182        } else {
1183                /* Start multiple block write */
1184                rv = sd_card_send_command( e, SD_CARD_CMD_WRITE_MULTIPLE_BLOCK, start_address);
1185                RTEMS_CLEANUP_RV( rv, sd_card_disk_block_write_stop_cleanup, "Send: SD_CARD_CMD_WRITE_MULTIPLE_BLOCK");
1186
1187                /* Multiple block write */
1188                for (i = 0; i < r->bufnum; ++i) {
1189#ifdef DEBUG
1190                        /* Check buffer */
1191                        if (r->bufs [i].length != e->block_size) {
1192                                RTEMS_DO_CLEANUP_RV( -RTEMS_INTERNAL_ERROR, rv, sd_card_disk_block_write_stop_cleanup, "Buffer and disk block size are not equal");
1193                        }
1194                        RTEMS_DEBUG_PRINT( "[%02u:%02u]: buffer = 0x%08x, size = %u\n", i + 1, r->bufnum, r->bufs [i].buffer, r->bufs [i].length);
1195#endif /* DEBUG */
1196
1197                        rv = sd_card_write( e, SD_CARD_START_BLOCK_MULTIPLE_BLOCK_WRITE, (uint8_t *) r->bufs [i].buffer, (int) e->block_size);
1198                        RTEMS_CLEANUP_RV( rv, sd_card_disk_block_write_stop_cleanup, "Write block");
1199                }
1200
1201                /* Stop multiple block write */
1202                rv = sd_card_stop_multiple_block_write( e);
1203                RTEMS_CLEANUP_RV( rv, sd_card_disk_block_write_cleanup, "Stop multiple block write");
1204        }
1205
1206        /* Get card status */
1207        rv = sd_card_send_command( e, SD_CARD_CMD_SEND_STATUS, 0);
1208        RTEMS_CHECK_RV( rv, "Send: SD_CARD_CMD_SEND_STATUS");
1209
1210        /* Stop */
1211        sc = sd_card_stop( e);
1212        RTEMS_CHECK_SC_RV( sc, "Stop");
1213
1214        /* Done */
1215        rtems_blkdev_request_done( r, RTEMS_SUCCESSFUL);
1216
1217        return 0;
1218
1219sd_card_disk_block_write_stop_cleanup:
1220
1221        /* Stop multiple block write */
1222        sd_card_stop_multiple_block_write( e);
1223
1224sd_card_disk_block_write_cleanup:
1225
1226        /* Get card status */
1227        rv = sd_card_send_command( e, SD_CARD_CMD_SEND_STATUS, 0);
1228        RTEMS_CHECK_RV( rv, "Send: SD_CARD_CMD_SEND_STATUS");
1229
1230        /* Stop */
1231        sd_card_stop( e);
1232
1233        /* Done */
1234        rtems_blkdev_request_done( r, RTEMS_IO_ERROR);
1235
1236        return 0;
1237}
1238
1239static int sd_card_disk_ioctl( rtems_disk_device *dd, uint32_t req, void *arg)
1240{
1241        RTEMS_DEBUG_PRINT( "dev = %u, req = %u, arg = 0x08%x\n", dev, req, arg);
1242        if (req == RTEMS_BLKIO_REQUEST) {
1243                rtems_device_minor_number minor = rtems_disk_get_minor_number( dd);
1244                sd_card_driver_entry *e = &sd_card_driver_table [minor];
1245                rtems_blkdev_request *r = (rtems_blkdev_request *) arg;
1246                int (*f)( sd_card_driver_entry *, rtems_blkdev_request *);
1247                uint32_t retries = e->retries;
1248                int result;
1249
1250                switch (r->req) {
1251                        case RTEMS_BLKDEV_REQ_READ:
1252                                f = sd_card_disk_block_read;
1253                                break;
1254                        case RTEMS_BLKDEV_REQ_WRITE:
1255                                f = sd_card_disk_block_write;
1256                                break;
1257                        default:
1258                                errno = EINVAL;
1259                                return -1;
1260                }
1261                do {
1262                        result = f( e, r);
1263                } while (retries-- > 0 && result != 0);
1264                return result;
1265
1266        } else if (req == RTEMS_BLKIO_CAPABILITIES) {
1267                *(uint32_t *) arg = RTEMS_BLKDEV_CAP_MULTISECTOR_CONT;
1268                return 0;
1269        } else {
1270                errno = EINVAL;
1271                return -1;
1272        }
1273}
1274
1275static rtems_status_code sd_card_disk_init( rtems_device_major_number major, rtems_device_minor_number minor, void *arg)
1276{
1277        rtems_status_code sc = RTEMS_SUCCESSFUL;
1278
1279        /* Initialize disk IO */
1280        sc = rtems_disk_io_initialize();
1281        RTEMS_CHECK_SC( sc, "Initialize RTEMS disk IO");
1282
1283        for (minor = 0; minor < sd_card_driver_table_size; ++minor) {
1284                sd_card_driver_entry *e = &sd_card_driver_table [minor];
1285                dev_t dev = rtems_filesystem_make_dev_t( major, minor);
1286                uint32_t retries = e->retries;
1287
1288                /* Initialize SD Card */
1289                do {
1290                        sc = sd_card_init( e);
1291                } while (retries-- > 0 && sc != RTEMS_SUCCESSFUL);
1292                RTEMS_CHECK_SC( sc, "Initialize SD Card");
1293
1294                /* Create disk device */
1295                sc = rtems_disk_create_phys( dev, e->block_size, e->block_number, sd_card_disk_ioctl, NULL, e->device_name);
1296                RTEMS_CHECK_SC( sc, "Create disk device");
1297        }
1298
1299        return RTEMS_SUCCESSFUL;
1300}
1301
1302/** @} */
1303
1304static const rtems_driver_address_table sd_card_disk_ops = {
1305        .initialization_entry = sd_card_disk_init,
1306        .open_entry = rtems_blkdev_generic_open,
1307        .close_entry = rtems_blkdev_generic_close,
1308        .read_entry = rtems_blkdev_generic_read,
1309        .write_entry = rtems_blkdev_generic_write,
1310        .control_entry = rtems_blkdev_generic_ioctl
1311};
1312
1313rtems_status_code sd_card_register( void)
1314{
1315        rtems_status_code sc = RTEMS_SUCCESSFUL;
1316        rtems_device_major_number major = 0;
1317
1318        sc = rtems_io_register_driver( 0, &sd_card_disk_ops, &major);
1319        RTEMS_CHECK_SC( sc, "Register disk SD Card driver");
1320
1321        return RTEMS_SUCCESSFUL;
1322}
Note: See TracBrowser for help on using the repository browser.