source: rtems/c/src/libchip/i2c/spi-sd-card.c @ 0e27119

4.11
Last change on this file since 0e27119 was 0e27119, checked in by Joel Sherrill <joel.sherrill@…>, on Oct 11, 2012 at 8:52:18 PM

Use proper 3 line form of license text

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