Context Navigation

source: rtems/c/src/libchip/i2c/spi-sd-card.c @ 5c587596

4.104.115

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: