Ticket #1356: spi-sd-card.c

File spi-sd-card.c, 39.1 KB (added by Gene Smith, on Jan 22, 2009 at 3:01:17 PM)

My complete spi-sd-card.c

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