Context Navigation

sdmmc.cpp @ 1063

Last change on this file since 1063 was 1052, checked in by alain, 7 years ago
few bugs
File size: 18.9 KB

Rev	Line
[555]	1	/*
	2	-- c++ --
[552]	3	*
	4	* SOCLIB_LGPL_HEADER_BEGIN
	5	*
	6	* This file is part of SoCLib, GNU LGPLv2.1.
	7	*
	8	* SoCLib is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU Lesser General Public License as published
	10	* by the Free Software Foundation; version 2.1 of the License.
	11	*
	12	* SoCLib is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with SoCLib; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	20	* 02110-1301 USA
	21	*
	22	* SOCLIB_LGPL_HEADER_END
	23	*
	24	* Copyright (c) UPMC, Lip6, SoC
	25	* manuel.bouyer@lip6.fr october 2013
	26	*
	27	* Maintainers: bouyer
	28	*/
	29
	30	#include <stdint.h>
	31	#include <errno.h>
[709]	32	#include <cstring>
[552]	33	#include <iostream>
	34	#include <fcntl.h>
	35	#include <cassert>
	36	#include "sdmmc.h"
	37
	38	namespace soclib { namespace caba {
	39
	40	using namespace soclib::caba;
	41
	42	////////////////////////
[557]	43	void SdMMC::genMealy()
[552]	44	{
	45	if(p_resetn.read() == false)
	46	{
[556]	47	spi_fsm = S_IDLE;
[1052]	48	m_acmd = false;
	49	m_sdstate = SD_IDLE;
[552]	50	return;
	51	}
[1052]	52
	53	if (p_spi_ss.read())
	54	{
	55	if (spi_fsm != S_IDLE)
	56	{
	57	std::cerr << name() << " deselect but not idle, state "
	58	<< std::dec << spi_fsm << " last cmd " << (int)command
	59	<< " args " << std::hex << args << std::dec
	60	<< " bitcount " << (int)spi_bitcount
	61	<< " idx " << m_data_idx << " len_snd " << m_datalen_snd
	62	<< " len_rcv " << m_datalen_rcv << std::endl;
	63	}
	64	spi_fsm = S_IDLE;
	65	spi_clk = p_spi_clk;
	66	spi_mosi_previous = p_spi_mosi;
	67	return;
[552]	68	}
	69
[1052]	70	switch(spi_fsm)
	71	{
	72	case S_IDLE:
	73	if (p_spi_clk.read() == 1 && spi_clk == 0) // rising edge
	74	{
	75	command = (command << 1) \| spi_mosi_previous;
	76	spi_bitcount = 6;
	77	spi_fsm = S_RECEIVE_CMD;
	78	}
[552]	79	break;
[1052]	80	case S_RECEIVE_CMD:
	81	if (p_spi_clk.read() == 1 && spi_clk == 0) // rising edge
	82	{
	83	command = (command << 1) \| spi_mosi_previous;
	84	if (spi_bitcount == 0)
	85	{
	86	if ((command & 0x80) == 0)
	87	{
	88	spi_fsm = S_RECEIVE_ARGS_START;
	89	}
	90	else
	91	{
[555]	92	#ifdef SOCLIB_MODULE_DEBUG0
[556]	93	std::cout << name() << " S_RECEIVE_CMD " << std::hex << (int)command << std::endl;
[552]	94	#endif
[1052]	95	spi_fsm = S_IDLE;
	96	}
	97	}
	98	else
	99	{
	100	spi_bitcount = spi_bitcount - 1;
	101	}
	102	}
[552]	103	break;
[1052]	104	case S_RECEIVE_ARGS_START:
	105	if (p_spi_clk.read() == 1 && spi_clk == 0) // rising edge
	106	{
	107	args = (args << 1) \| spi_mosi_previous;
	108	spi_bitcount = 30;
	109	spi_fsm = S_RECEIVE_ARGS;
	110	}
[552]	111	break;
[1052]	112	case S_RECEIVE_ARGS:
	113	if (p_spi_clk.read() == 1 && spi_clk == 0) // rising edge
	114	{
	115	args = (args << 1) \| spi_mosi_previous;
	116	if (spi_bitcount == 0)
	117	{
	118	spi_bitcount = 7;
	119	spi_fsm = S_RECEIVE_CRC;
	120	}
	121	else
	122	{
	123	spi_bitcount = spi_bitcount - 1;
	124	}
	125	}
	126	break;
	127	case S_RECEIVE_CRC:
	128	if (p_spi_clk.read() == 1 && spi_clk == 0) // rising edge
	129	{
	130	cmdcrc = (cmdcrc << 1) \| spi_mosi_previous;
	131	if (spi_bitcount == 0)
	132	{
	133	handle_sdmmc_cmd(command, args);
	134	spi_bitcount = 0; // SEND_DATA will reset it
	135	spi_fsm = S_SEND_DATA;
	136	m_data_idx = 0;
	137	}
	138	else
	139	{
	140	spi_bitcount = spi_bitcount - 1;
	141	}
	142	}
	143	break;
[552]	144
[1052]	145	case S_SEND_DATA:
	146	if (p_spi_clk.read() == 0 && spi_clk == 1) // falling edge
	147	{
	148	if (spi_bitcount == 0)
	149	{
	150	if (m_data_idx != m_datalen_snd)
	151	{
	152	spi_shiftreg = m_databuf[m_data_idx];
	153	spi_bitcount = 7;
	154	spi_fsm = S_SEND_DATA;
	155	m_data_idx++;
[555]	156	#ifdef SOCLIB_MODULE_DEBUG0
[552]	157	std::cout << name() << " S_SEND_DATA " << std::dec << m_datalen_snd << " idx " << m_data_idx << " " << std::hex << (uint32_t)m_databuf[m_data_idx] << std::endl;
	158	#endif
[1052]	159	}
	160	else if (m_datalen_rcv != 0)
	161	{
	162	spi_fsm = S_RECEIVE_DATA_WAIT;
	163	spi_bitcount = 7;
	164	m_data_idx = 0;
	165	}
	166	else
	167	{
	168	spi_fsm = S_IDLE;
	169	}
	170	}
	171	else
	172	{
	173	spi_bitcount = spi_bitcount - 1;
	174	spi_shiftreg = spi_shiftreg << 1;
	175	}
	176	}
	177	break;
	178	/////////////////////////
	179	case S_RECEIVE_DATA_WAIT:
	180	if (p_spi_clk.read() == 1 && spi_clk == 0) // rising edge
	181	{
	182	uint8_t s_data;
	183	s_data = (m_databuf[0] << 1) \| spi_mosi_previous;
	184	m_databuf[0] = s_data;
	185	if (spi_bitcount == 0)
	186	{
[555]	187	#ifdef SOCLIB_MODULE_DEBUG
[1052]	188	std::cout << name() << " S_RECEIVE_DATA_WAIT " << std::dec << (int)s_data << std::endl;
[555]	189	#endif
[1052]	190	spi_bitcount = 7;
	191	if (s_data == 0xfe) // data start token
	192	{
	193	spi_fsm = S_RECEIVE_DATA;
	194	m_data_idx = 1;
	195	}
	196	else
	197	{
[555]	198	#ifdef SOCLIB_MODULE_DEBUG
[1052]	199	std::cout << name() << " S_RECEIVE_DATA_WAIT " << std::hex << (int)s_data << std::endl;
[555]	200	#endif
[1052]	201	spi_fsm = S_RECEIVE_DATA_WAIT;
	202	}
	203	}
	204	else
	205	{
	206	spi_bitcount = spi_bitcount - 1;
	207	}
	208	}
	209	break;
	210	////////////////////
	211	case S_RECEIVE_DATA:
	212	if (p_spi_clk.read() == 1 && spi_clk == 0) // rising edge
	213	{
	214	m_databuf[m_data_idx] = (m_databuf[m_data_idx] << 1) \| spi_mosi_previous;
	215	if (spi_bitcount == 0)
	216	{
	217	m_data_idx++;
	218	if (m_data_idx != m_datalen_rcv)
	219	{
	220	spi_fsm = S_RECEIVE_DATA;
	221	spi_bitcount = 7;
	222	}
	223	else
	224	{
	225	handle_sdmmc_write(command, args);
	226	if (m_datalen_snd > 0)
	227	{
	228	spi_bitcount = 0; // SEND_DATA will reset it
	229	spi_fsm = S_SEND_DATA;
	230	m_data_idx = 0;
	231	}
	232	else
	233	{
	234	spi_fsm = S_IDLE;
	235	}
	236	}
	237	}
	238	else
	239	{
	240	spi_bitcount = spi_bitcount - 1;
	241	}
	242	}
	243	break;
	244	} // end switch spi_fsm
[552]	245
[1052]	246	//// now generate output signal
[557]	247
[1052]	248	switch(spi_fsm)
	249	{
	250	case S_IDLE:
	251	p_spi_miso = !p_spi_ss.read();
[552]	252	break;
[1052]	253
	254	case S_SEND_DATA:
	255	p_spi_miso = (spi_shiftreg & 0x80) != 0;
	256	break;
	257
	258	default:
	259	p_spi_miso = !p_spi_ss.read();
[552]	260	break;
	261	}
[1052]	262
	263	//// sample inputs
[557]	264	spi_clk = p_spi_clk.read();
[574]	265	spi_mosi_previous = p_spi_mosi;
[1052]	266
[557]	267	} // end GenMealy()
[552]	268
	269
[1052]	270	////////////////////////////////////////////////////////
[552]	271	void SdMMC::handle_sdmmc_cmd(uint8_t cmd, uint32_t data)
	272	{
	273	m_datalen_rcv = 0;
[1052]	274	m_databuf[0] = 0x04; // default value : illegal command
	275	m_datalen_snd = 1; // default value : 1 byte
[552]	276
	277	if (m_sdstate == SD_IDLE)
	278	m_databuf[0] \|= 0x01; // idle
	279
[1052]	280	if ((cmd & 0x40) == 0)
	281	{
[552]	282	//illegal command
	283	return;
	284	}
	285	cmd &= 0x3f;
[1052]	286
	287	if (m_acmd)
	288	{
[555]	289	#ifdef SOCLIB_MODULE_DEBUG0
[1052]	290	std::cout << name() << " new acmd " << std::dec << (int)cmd << " args " << std::hex << data << " crc " << (int)cmdcrc << std::endl;
[552]	291	#endif
	292	m_acmd = false;
[1052]	293	switch (cmd)
	294	{
	295	case 41: // ACD41 : Send OP_COND
	296	m_databuf[0] = 0x0; // card ready
	297	m_datalen_snd = 1;
	298	m_sdstate = SD_READY;
	299	break;
	300	case 51: // send SCR
	301	m_databuf[ 0] = (m_sdstate == SD_IDLE) ? 0x1 : 0x0; // R1
	302	m_databuf[ 1] = 0xfe; // data token
	303	m_databuf[ 2] = 0x00; // SCR_STRUCTURE / SD_SPEC
	304	m_databuf[ 3] = 0x05; // DATA_STAT_AFTER_ERASE, SD_SECURITY, SD_BUS_WIDTHS
	305	m_databuf[ 4] = 0; // SD_SPEC3, EX_SECURITY, SD_SPEC4
	306	m_databuf[ 5] = 0; // CMD_SUPPORT
	307	m_databuf[ 6] = 0; // vendor specific
	308	m_databuf[ 7] = 0; // vendor specific
	309	m_databuf[ 8] = 0; // vendor specific
	310	m_databuf[ 9] = 0; // vendor specific
	311	m_databuf[10] = 0x0; // CRC16
	312	m_databuf[11] = 0x0; // CRC16
	313	m_datalen_snd = 12;
	314	break;
	315	default:
	316	std::cout << name() << " unknown acmd " << std::dec
	317	<< (int)cmd << std::endl;
	318	break; // return illegal command
[552]	319	}
[1052]	320	}
	321	else
	322	{
[555]	323	#ifdef SOCLIB_MODULE_DEBUG0
[1052]	324	std::cout << name() << " new cmd " << std::dec << (int)cmd << " args " << std::hex << data << " crc " << (int)cmdcrc << std::endl;
[552]	325	#endif
[1052]	326	switch (cmd)
	327	{
	328	///////
	329	case 0: // CMD0
	330	m_databuf[0] = 0x1;
	331	m_datalen_snd = 1;
	332	m_sdstate = SD_IDLE;
	333	break;
	334	///////
	335	case 8: // CMD8
	336	// reply with illegal command for now
	337	break;
	338	///////
	339	case 9: // CMD9 : send CSD
	340	{
	341	// we use a block len of 1024
	342	uint32_t csize = ((m_device_size + (512 * 1024) - 1) / (512 * 1024)) - 1;
	343	m_databuf[ 0] = (m_sdstate == SD_IDLE) ? 0x1 : 0x0; // R1
	344	m_databuf[ 1] = 0xfe; // data token
	345	m_databuf[ 2] = 0x00; // CSD_STRUCTURE
	346	m_databuf[ 3] = 0xe; // TAAC
	347	m_databuf[ 4] = 0; // NSAC
	348	m_databuf[ 5] = 0x32; // TRAN_SPEED
	349	m_databuf[ 6] = 0x5b; // CCC_H
	350	m_databuf[ 7] = 0x5a; // CCC_L + READ_BL_LEN
	351	m_databuf[ 8] = 0x80; // READ_BL_PARTIAL, R/W_BLK_MISALIGN, DSR_IMP
	352	m_databuf[ 8] \|= (csize >> 10) & 0x03; // CSIZE[12-11]
	353	m_databuf[ 9] = (csize >> 2) & 0xff; // CSIZE[10-2]
	354	m_databuf[10] = (csize << 6) & 0xc0; // CSIZE[1-0]
	355	m_databuf[10] \|= 0; // R_CURR_MIN, R_CURR_MAX
	356	m_databuf[11] = 0x3; // W_CURR_MIN, W_CURR_MAX, CSIZE_MULT[2-1];
	357	m_databuf[12] = 0xff; // CSIZE_MULT[1], ERASE_BLK_EN, ERASE_SECTOR_SIZE[6-1]
	358	m_databuf[13] = 0x80; // ERASE_SECTOR_SIZE[0]. WP_GRP_SIZE
	359	m_databuf[14] = 0x0a; // WP_GRP_ENABLE, R2W_FACTOR, WRITE_BL_LEN[2-3]
	360	m_databuf[15] = 0x40; // WRITE_BL_LEN[0-1], WR_BL_PARTIAL
	361	m_databuf[16] = 0; // FILE_FORMAT
	362	m_databuf[17] = 0x1; // CRC7
	363	m_databuf[18] = 0x0; // CRC16
	364	m_databuf[19] = 0x0; // CRC16
	365	m_datalen_snd = 20;
	366	}
	367	break;
	368	////////
	369	case 10: // CMD10 : send CID
	370	m_databuf[ 0] = (m_sdstate == SD_IDLE) ? 0x1 : 0x0; // R1
	371	m_databuf[ 1] = 0xfe; // data token
	372	m_databuf[ 2] = 0xda; // MID
	373	m_databuf[ 3] = 'P'; // OID
	374	m_databuf[ 4] = '6'; // OID
	375	m_databuf[ 5] = 's'; // PNM
	376	m_databuf[ 6] = 'o'; // PNM
	377	m_databuf[ 7] = 'c'; // PNM
	378	m_databuf[ 8] = 's'; // PNM
	379	m_databuf[ 9] = 'd'; // PNM
	380	m_databuf[10] = 0x01; // PRV
	381	m_databuf[11] = 0xde; // PSN
	382	m_databuf[12] = 0xad; // PSN
	383	m_databuf[13] = 0xbe; // PSN
	384	m_databuf[14] = 0xef; // PSN
	385	m_databuf[15] = 10; // MDT
	386	m_databuf[16] = 13; // MDT
	387	m_databuf[17] = 0x1; // CRC7
	388	m_databuf[18] = 0x0; // CRC16
	389	m_databuf[19] = 0x0; // CRC16
	390	m_datalen_snd = 20;
	391	break;
	392	////////
	393	case 16: // CMD16 : set block size
	394	if (m_sdstate != SD_IDLE && data == 512)
	395	{
	396	m_databuf[0] = 0x00;
	397	m_datalen_snd = 1;
	398	} // else illegal command
	399	break;
	400	////////
	401	case 17: // CMD17 : read data block
	402	{
	403	int ret;
	404	if (m_sdstate == SD_IDLE) // return illegal command
	405	{
	406	return;
	407	}
	408	if (data >= m_device_size) // return "out of range"
	409	{
	410	std::cerr << name() << " read: request " << data
	411	<< " past end of file " << m_device_size << std::endl;
	412	m_databuf[0] = 0x00; // R1 OK
	413	m_databuf[1] = 0x08; // error tocken "out of range"
	414	m_datalen_snd = 2;
	415	return;
	416	}
	417	do
	418	{
	419	if (lseek(m_fd, data, SEEK_SET) < 0)
	420	{
	421	std::cerr << name() << " lseek: " <<
	422	strerror(errno) << std::endl;
	423	m_databuf[0] = 0x00; // R1 OK
	424	m_databuf[1] = 0x02; // error tocken "CC err"
	425	m_datalen_snd = 2;
	426	return;
	427	}
	428	ret = read(m_fd, &m_databuf[2], 512);
	429	} while (ret < 0 && errno == EINTR);
	430	if (ret < 0)
	431	{
	432	std::cerr << name() << " read: " << strerror(errno) << std::endl;
	433	m_databuf[0] = 0x00; // R1 OK
	434	m_databuf[1] = 0x04; // error tocken "card ECC failed"
	435	m_datalen_snd = 2;
	436	return;
	437	}
	438	m_databuf[514] = m_databuf[515] = 0; // XXX CRC
	439	m_databuf[0] = 0x0; // R1
	440	m_databuf[1] = 0xfe; // start block tocken
	441	m_datalen_snd = 516;
	442	}
	443	break;
	444	////////
	445	case 24: // CMD 24 : write data block
	446	{
	447	if (m_sdstate == SD_IDLE) // return illegal command
	448	{
	449	return;
	450	}
[555]	451	#ifdef SOCLIB_MODULE_DEBUG
	452	std::cout << name() << " new cmd write " << std::dec << (int)cmd << " args " << std::hex << data << std::endl;
	453	#endif
[1052]	454	m_databuf[0] = 0x0; // R1
	455	m_datalen_snd = 1;
	456	m_datalen_rcv = 512 + 2 + 1; // data + tocken + CRC
	457	}
	458	break;
	459	////////
	460	case 55: // CMD55 : app-specific command follow
	461	m_acmd = true;
	462	m_databuf[0] = (m_sdstate == SD_IDLE) ? 0x1 : 0x0;
	463	m_datalen_snd = 1;
	464	break;
	465	////////
	466	case 58: // CMD 58 : send OCR
	467	m_databuf[4] = (m_sdstate == SD_IDLE) ? 0x1 : 0x0; // R1
	468	m_databuf[3] = 0x80; // power up complete, SDSC
	469	m_databuf[2] = 0xff; // all voltages supported
	470	m_databuf[1] = 0x00;
	471	m_databuf[0] = 0x00;
	472	m_datalen_snd = 5;
	473	break;
	474	////////
	475	default: // return illegal command
	476	std::cout << name() << " unknown cmd " << std::dec << (int)cmd << std::endl;
	477	break;
[552]	478	}
	479	}
[1052]	480	} // end handle_sdmmc_cmd()
[552]	481
[1052]	482	///////////////////////////////////////////////////////////
[555]	483	void SdMMC::handle_sdmmc_write(uint8_t cmd, uint32_t data)
[552]	484	{
[555]	485	m_datalen_rcv = 0;
	486	cmd &= 0x3f;
	487	#ifdef SOCLIB_MODULE_DEBUG
	488	std::cout << name() << " cmd write " << std::dec << (int)cmd << " args " << std::hex << data << std::endl;
	489	#endif
[1052]	490	switch(cmd)
	491	{
	492	case 24: // CMD24 : write data block
	493	{
	494	int ret;
	495	assert(m_sdstate != SD_IDLE && "can't write in idle state");
	496	if (data >= m_device_size)
	497	{
	498	std::cerr << name() << " write: request " << data
	499	<< " past end of file " << m_device_size << std::endl;
	500	m_databuf[0] = 0xd; // write error
	501	m_datalen_snd = 1;
	502	return;
	503	}
	504	do
	505	{
	506	if (lseek(m_fd, data, SEEK_SET) < 0)
	507	{
	508	std::cerr << name() << " lseek: " << strerror(errno) << std::endl;
	509	m_databuf[0] = 0xd; // write error
	510	m_datalen_snd = 1;
	511	return;
	512	}
	513	ret = write(m_fd, &m_databuf[1], 512);
	514	}
	515	while (ret < 0 && errno == EINTR);
	516	if (ret < 0)
	517	{
	518	std::cerr << name() << " write: " << strerror(errno) << std::endl;
	519	m_databuf[0] = 0xd; // write error
	520	m_datalen_snd = 1;
	521	return;
	522	}
	523	m_databuf[0] = 0x5; // write complete
	524	m_databuf[1] = 0x0; // busy
	525	m_datalen_snd = 2;
	526	}
[555]	527	break;
	528	default:
[1052]	529	{
	530	std::cerr << name() << " unkown write cmd " << std::dec << (int)cmd << std::endl;
	531	m_databuf[0] = 0xd; // write error;
	532	m_datalen_snd = 1;
	533	}
[555]	534	}
[552]	535	return;
	536	}
	537
[1052]	538	//////////////////////////////////////////////////////////////
[552]	539	SdMMC::SdMMC( sc_core::sc_module_name name,
[1052]	540	const std::string &filename,
	541	const uint32_t latency)
[552]	542
	543	: caba::BaseModule(name),
	544	m_latency(latency),
	545	p_clk("p_clk"),
	546	p_resetn("p_resetn"),
	547	p_spi_ss("p_spi_ss"),
	548	p_spi_clk("p_spi_clk"),
	549	p_spi_mosi("p_spi_mosi"),
	550	p_spi_miso("p_spi_miso")
	551	{
	552	std::cout << " - Building SdMMC " << name << std::endl;
	553
[557]	554	SC_METHOD(genMealy);
[552]	555	dont_initialize();
	556	sensitive << p_clk.neg();
[557]	557	sensitive << p_resetn;
	558	sensitive << p_spi_ss;
	559	sensitive << p_spi_clk;
[552]	560
	561	m_fd = ::open(filename.c_str(), O_RDWR);
	562	if ( m_fd < 0 )
	563	{
	564	std::cout << "Error in component SdMMC : " << name
	565	<< " Unable to open file " << filename << std::endl;
	566	exit(1);
	567	}
	568	m_device_size = lseek(m_fd, 0, SEEK_END);
	569
	570	} // end constructor
	571
	572	SdMMC::~SdMMC()
	573	{
	574	}
	575
	576
	577	//////////////////////////
	578	void SdMMC::print_trace()
	579	{
	580	const char* spi_str[] =
	581	{
[1052]	582	"S_IDLE",
	583	"S_RECEIVE_CMD",
	584	"S_RECEIVE_ARGS_START",
	585	"S_RECEIVE_ARGS",
	586	"S_RECEIVE_CRC",
	587	"S_RECEIVE_DATA_START",
	588	"S_RECEIVE_DATA",
	589	"S_SEND_DATA",
	590	"S_NOP",
[552]	591	};
[556]	592	if (spi_clk != p_spi_clk.read()) {
	593	std::cout << name() << " SPI_FSM : " << spi_str[spi_fsm]
[552]	594	<< std::dec
[556]	595	<< " clk " << spi_clk << "->" << p_spi_clk << " ss " << p_spi_ss
[552]	596	<< " mosi " << p_spi_mosi << " miso " << p_spi_miso
	597	<< std::endl;
[556]	598	std::cout << " spi_shiftreg: " << std::hex << (int)spi_shiftreg
	599	<< " spi_bitcount: " << (int)spi_bitcount
[552]	600	<< std::endl;
	601	}
	602	}
	603	}} // end namespace
	604
	605	// Local Variables:
	606	// tab-width: 4
	607	// c-basic-offset: 4
	608	// c-file-offsets:((innamespace . 0)(inline-open . 0))
	609	// indent-tabs-mode: nil
	610	// End:
	611
	612	// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
	613

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

Context Navigation

source: trunk/modules/sdmmc/caba/source/src/sdmmc.cpp @ 1063

Download in other formats: