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

Last change on this file since 553 was 552, checked in by bouyer, 11 years ago

Add a SPI SD/MMC card model. Write command not implemented yet.
Known to work with the TSAR SPI boot loader and NetBSD's sdmmc driver.
The data are backed by a file in the host's filesystem, as vci_block_device
does.
The purpose of this model is to provide a sdmmc device to the vci_spi
controller. It's not intended to respect timings or a real SD/MMC device.
File size: 11.5 KB
Line 
1/* -*- c++ -*-
2 *
3 * SOCLIB_LGPL_HEADER_BEGIN
4 *
5 * This file is part of SoCLib, GNU LGPLv2.1.
6 *
7 * SoCLib is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; version 2.1 of the License.
10 *
11 * SoCLib is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with SoCLib; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 * 02110-1301 USA
20 *
21 * SOCLIB_LGPL_HEADER_END
22 *
23 * Copyright (c) UPMC, Lip6, SoC
24 *         manuel.bouyer@lip6.fr october 2013
25 *
26 * Maintainers: bouyer
27 */
28
29#include <stdint.h>
30#include <errno.h>
31#include <iostream>
32#include <fcntl.h>
33#include <cassert>
34#include "sdmmc.h"
35
36namespace soclib { namespace caba {
37
38using namespace soclib::caba;
39
40////////////////////////
41void SdMMC::transition()
42{
43    if(p_resetn.read() == false) 
44    {
45        r_spi_fsm  = S_IDLE;
46        m_acmd     = false;     
47        m_sdstate  = SD_IDLE;
48        return;
49    } 
50    if (p_spi_ss.read()) {
51        r_spi_fsm  = S_IDLE;
52        return;
53    }
54
55    r_spi_clk = p_spi_clk;
56
57    switch(r_spi_fsm) {
58    case S_IDLE:
59        if (p_spi_clk.read() == 1 && r_spi_clk.read() == 0) {
60                // rising edge
61                r_command = (r_command << 1) | p_spi_mosi;
62                r_spi_bitcount = 6;
63                r_spi_fsm = S_RECEIVE_CMD;
64        }
65        break;
66    case S_RECEIVE_CMD:
67        if (p_spi_clk.read() == 1 && r_spi_clk.read() == 0) {
68                // rising edge
69                r_command = (r_command << 1) | p_spi_mosi;
70                r_spi_bitcount = r_spi_bitcount - 1;
71                if (r_spi_bitcount == 0) {
72                        if (((r_command << 1) & 0x80) == 0) {
73                                r_spi_fsm = S_RECEIVE_ARGS_START;
74                        } else {
75#ifdef SOCLIB_MODULE_DEBUG
76                                std::cout << name() << " S_RECEIVE_CMD " << std::hex << ((int)((r_command << 1) | p_spi_mosi) & 0xff) << std::endl;
77#endif
78                                r_spi_fsm = S_IDLE;
79                        }
80                }
81        }
82        break;
83    case S_RECEIVE_ARGS_START:
84        if (p_spi_clk.read() == 1 && r_spi_clk.read() == 0) {
85                // rising edge
86                r_args = (r_args << 1) | p_spi_mosi;
87                r_spi_bitcount = 30;
88                r_spi_fsm = S_RECEIVE_ARGS;
89        }
90        break;
91    case S_RECEIVE_ARGS:
92        if (p_spi_clk.read() == 1 && r_spi_clk.read() == 0) {
93                // rising edge
94                r_args = (r_args << 1) | p_spi_mosi;
95                r_spi_bitcount = r_spi_bitcount - 1;
96                if (r_spi_bitcount == 0) {
97                        r_spi_bitcount = 7;
98                        r_spi_fsm = S_RECEIVE_CRC;
99                }
100        }
101        break;
102    case S_RECEIVE_CRC:
103        if (p_spi_clk.read() == 1 && r_spi_clk.read() == 0) {
104                // rising edge
105                uint8_t crc = (r_cmdcrc << 1) | p_spi_mosi;
106                r_cmdcrc = crc;
107                if (r_spi_bitcount == 0) {
108                        handle_sdmmc_cmd(r_command.read(), r_args.read());
109                        r_spi_bitcount = 0; // SEND_DATA will reset it
110                        r_spi_fsm = S_SEND_DATA;
111                        m_data_idx = 0;
112                } else {
113                        r_spi_bitcount = r_spi_bitcount - 1;
114                }
115        }
116        break;
117       
118    case S_SEND_DATA:
119        if (p_spi_clk.read() == 0 && r_spi_clk.read() == 1) {
120                // falling edge
121                if (r_spi_bitcount == 0) {
122                        if (m_data_idx != m_datalen_snd) {     
123                                r_spi_shiftreg = m_databuf[m_data_idx];
124                                r_spi_bitcount = 7;
125                                r_spi_fsm = S_SEND_DATA;
126                                m_data_idx++;
127#ifdef SOCLIB_MODULE_DEBUG
128                        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;
129#endif
130                        } else if (m_datalen_rcv != 0) {
131                                r_spi_fsm = S_RECEIVE_DATA;
132                                r_spi_bitcount = 7;
133                                m_data_idx = 0;
134                        } else {
135                                r_spi_fsm = S_IDLE;
136                        }
137                } else {
138                        r_spi_bitcount = r_spi_bitcount - 1;
139                        r_spi_shiftreg = r_spi_shiftreg << 1;
140                }
141        }
142        break;
143    }
144}  // end transition
145
146//////////////////////
147void SdMMC::genMoore()
148{
149    switch(r_spi_fsm) {
150    case S_IDLE:
151        p_spi_miso = !p_spi_ss.read();
152        break;
153    case S_SEND_DATA:
154        p_spi_miso = (r_spi_shiftreg & 0x80) != 0;
155        break;
156    default:
157        p_spi_miso = !p_spi_ss.read();
158        break;
159    }
160} // end GenMoore()
161
162
163//////////////////////
164void SdMMC::handle_sdmmc_cmd(uint8_t cmd, uint32_t data)
165{
166        m_datalen_rcv = 0;
167        m_databuf[0] = 0x04; // illegal command
168        m_datalen_snd = 1;
169
170        if (m_sdstate == SD_IDLE)
171                m_databuf[0] |= 0x01; // idle
172
173        if ((cmd & 0x40) == 0) {
174                //illegal command
175                return;
176        }
177        cmd &= 0x3f;
178        if (m_acmd) {
179#ifdef SOCLIB_MODULE_DEBUG
180        std::cout << name() << " new acmd " << std::dec << (int)cmd << " args " << std::hex << data << " crc " << (int)r_cmdcrc << std::endl;
181#endif
182            m_acmd = false;
183            switch (cmd) {
184            case 41:
185                m_databuf[0] = 0x0; // card ready
186                m_datalen_snd = 1;
187                m_sdstate = SD_READY;
188                break;
189            case 51:
190                // send SCR
191                m_databuf[ 0] = (m_sdstate == SD_IDLE) ? 0x1 : 0x0; // R1
192                m_databuf[ 1] = 0xfe; // data token
193                m_databuf[ 2] = 0x00; // SCR_STRUCTURE / SD_SPEC
194                m_databuf[ 3] = 0x05; // DATA_STAT_AFTER_ERASE, SD_SECURITY, SD_BUS_WIDTHS
195                m_databuf[ 4] = 0;    // SD_SPEC3, EX_SECURITY, SD_SPEC4
196                m_databuf[ 5] = 0;    // CMD_SUPPORT
197                m_databuf[ 6] = 0;    // vendor specific
198                m_databuf[ 7] = 0;    // vendor specific
199                m_databuf[ 8] = 0;    // vendor specific
200                m_databuf[ 9] = 0;    // vendor specific
201                m_databuf[10] = 0x0;  // CRC16
202                m_databuf[11] = 0x0;  // CRC16
203                m_datalen_snd = 12;
204                break;
205            default:
206                std::cout << name() << " unknown acmd " << std::dec
207                    << (int)cmd << std::endl;
208                break; // return illegal command
209            }
210        } else {
211#ifdef SOCLIB_MODULE_DEBUG
212        std::cout << name() << " new cmd " << std::dec << (int)cmd << " args " << std::hex << data << " crc " << (int)r_cmdcrc << std::endl;
213#endif
214            switch (cmd) {
215            case 0:
216                m_databuf[0] = 0x1;
217                m_datalen_snd = 1;
218                m_sdstate = SD_IDLE;
219                break;
220            case 8:
221                // reply with illegal command for now
222                break;
223            case 9:
224              {
225                // send CSD
226                // we use a block len of 1024
227                uint32_t csize = ((m_device_size + (512 * 1024) - 1) / (512 * 1024)) - 1;
228                m_databuf[ 0]  = (m_sdstate == SD_IDLE) ? 0x1 : 0x0; // R1
229                m_databuf[ 1]  = 0xfe; // data token
230                m_databuf[ 2]  = 0x00; // CSD_STRUCTURE
231                m_databuf[ 3]  = 0xe;  // TAAC
232                m_databuf[ 4]  = 0;    // NSAC
233                m_databuf[ 5]  = 0x32; // TRAN_SPEED
234                m_databuf[ 6]  = 0x5b; // CCC_H
235                m_databuf[ 7]  = 0x5a; // CCC_L + READ_BL_LEN
236                m_databuf[ 8]  = 0x80; // READ_BL_PARTIAL, R/W_BLK_MISALIGN, DSR_IMP
237                m_databuf[ 8] |= (csize >> 10) & 0x03; // CSIZE[12-11]
238                m_databuf[ 9]  = (csize >>  2) & 0xff; // CSIZE[10-2]
239                m_databuf[10]  = (csize <<  6) & 0xc0; // CSIZE[1-0]
240                m_databuf[10] |= 0;    // R_CURR_MIN, R_CURR_MAX
241                m_databuf[11]  = 0x3;  // W_CURR_MIN, W_CURR_MAX, CSIZE_MULT[2-1];
242                m_databuf[12]  = 0xff; // CSIZE_MULT[1], ERASE_BLK_EN, ERASE_SECTOR_SIZE[6-1]
243                m_databuf[13]  = 0x80; // ERASE_SECTOR_SIZE[0]. WP_GRP_SIZE
244                m_databuf[14]  = 0x0a; // WP_GRP_ENABLE, R2W_FACTOR, WRITE_BL_LEN[2-3]
245                m_databuf[15]  = 0x40; // WRITE_BL_LEN[0-1], WR_BL_PARTIAL
246                m_databuf[16]  = 0;    // FILE_FORMAT
247                m_databuf[17]  = 0x1;  // CRC7
248                m_databuf[18]  = 0x0;  // CRC16
249                m_databuf[19]  = 0x0;  // CRC16
250                m_datalen_snd  = 20;
251                break;
252              }
253            case 10:
254                // send CID
255                m_databuf[ 0] = (m_sdstate == SD_IDLE) ? 0x1 : 0x0; // R1
256                m_databuf[ 1] = 0xfe; // data token
257                m_databuf[ 2] = 0xda; // MID
258                m_databuf[ 3] = 'P';  // OID
259                m_databuf[ 4] = '6';  // OID
260                m_databuf[ 5] = 's';  // PNM
261                m_databuf[ 6] = 'o';  // PNM
262                m_databuf[ 7] = 'c';  // PNM
263                m_databuf[ 8] = 's';  // PNM
264                m_databuf[ 9] = 'd';  // PNM
265                m_databuf[10] = 0x01; // PRV
266                m_databuf[11] = 0xde; // PSN
267                m_databuf[12] = 0xad; // PSN
268                m_databuf[13] = 0xbe; // PSN
269                m_databuf[14] = 0xef; // PSN
270                m_databuf[15] = 10;   // MDT
271                m_databuf[16] = 13;   // MDT
272                m_databuf[17] = 0x1;  // CRC7
273                m_databuf[18] = 0x0;  // CRC16
274                m_databuf[19] = 0x0;  // CRC16
275                m_datalen_snd = 20;
276                break;
277            case 16:
278                // set block size
279                if (m_sdstate != SD_IDLE && data == 512) {
280                        m_databuf[0] = 0x00;
281                        m_datalen_snd = 1;
282                } // else illegal command
283                break;
284            case 17:
285              {
286                int ret;
287                // read data block
288                if (m_sdstate == SD_IDLE) {
289                        // return illegal command
290                        return;
291                }
292                if (data >= m_device_size) {
293                        std::cerr << name() << " read: request " << data
294                            << " past end of file " << m_device_size << std::endl;
295                        m_databuf[0] = 0x00; // R1 OK
296                        m_databuf[1] = 0x08; // error tocken "out of range"
297                        m_datalen_snd = 2;
298                        return;
299                }
300                do {
301                        if (lseek(m_fd, data, SEEK_SET) < 0) {
302                                std::cerr << name() << " lseek: " <<
303                                  strerror(errno) << std::endl;
304                                m_databuf[0] = 0x00; // R1 OK
305                                m_databuf[1] = 0x02; // error tocken "CC err"
306                                m_datalen_snd = 2;
307                                return;
308                        }
309                        ret = read(m_fd, &m_databuf[2], 512);
310                } while (ret < 0 && errno == EINTR);
311                if (ret < 0) {
312                        std::cerr << name() << " read: " <<
313                          strerror(errno) << std::endl;
314                        m_databuf[0] = 0x00; // R1 OK
315                        m_databuf[1] = 0x04; // error tocken "card ECC failed"
316                        m_datalen_snd = 2;
317                        return;
318                }
319                m_databuf[514] = m_databuf[515] = 0; // XXX CRC
320                m_databuf[0] = 0x0; // R1
321                m_databuf[1] = 0xfe; // start block tocken
322                m_datalen_snd = 516;
323                break;
324              }
325            case 55:
326                // app-specific command follow
327                m_acmd = true;
328                m_databuf[0] = (m_sdstate == SD_IDLE) ? 0x1 : 0x0;
329                m_datalen_snd = 1;
330                break;
331            case 58:
332                // send OCR
333                m_databuf[4] = (m_sdstate == SD_IDLE) ? 0x1 : 0x0; // R1
334                m_databuf[3] = 0x80; // power up complete, SDSC
335                m_databuf[2] = 0xff; // all voltages supported
336                m_databuf[1] = 0x00; 
337                m_databuf[0] = 0x00; 
338                m_datalen_snd = 5;
339                break;
340            default:
341                std::cout << name() << " unknown cmd " << std::dec
342                    << (int)cmd << std::endl;
343                break; // return illegal command
344            }
345        }
346}
347
348void SdMMC::handle_sdmmc_write()
349{
350        return;
351}
352
353//////////////////////////////////////////////////////////////////////////////
354SdMMC::SdMMC( sc_core::sc_module_name              name, 
355                                const std::string                    &filename,
356                                const uint32_t                       latency)
357
358: caba::BaseModule(name),
359        m_latency(latency),
360        p_clk("p_clk"),
361        p_resetn("p_resetn"),
362        p_spi_ss("p_spi_ss"),
363        p_spi_clk("p_spi_clk"),
364        p_spi_mosi("p_spi_mosi"),
365        p_spi_miso("p_spi_miso")
366{
367    std::cout << "  - Building SdMMC " << name << std::endl;
368
369        SC_METHOD(transition);
370    dont_initialize();
371    sensitive << p_clk.pos();
372
373        SC_METHOD(genMoore);
374    dont_initialize();
375    sensitive << p_clk.neg();
376
377    m_fd = ::open(filename.c_str(), O_RDWR);
378    if ( m_fd < 0 ) 
379    {
380            std::cout << "Error in component SdMMC : " << name
381                      << " Unable to open file " << filename << std::endl;
382            exit(1);
383    }
384    m_device_size = lseek(m_fd, 0, SEEK_END);
385
386} // end constructor
387
388SdMMC::~SdMMC()
389{
390}
391
392
393//////////////////////////
394void SdMMC::print_trace()
395{
396        const char* spi_str[] = 
397    {
398                "S_IDLE",
399                "S_RECEIVE_CMD",
400                "S_RECEIVE_ARGS_START",
401                "S_RECEIVE_ARGS",
402                "S_RECEIVE_CRC",
403                "S_RECEIVE_DATA",
404                "S_RECEIVE_DATA_END",
405                "S_SEND_DATA",
406                "S_NOP",
407        };
408        if (r_spi_clk != p_spi_clk) {
409        std::cout << name() << " SPI_FSM : " << spi_str[r_spi_fsm] 
410            << std::dec
411            << " clk " << r_spi_clk << "->" << p_spi_clk << " ss " << p_spi_ss
412            << " mosi " << p_spi_mosi << " miso " << p_spi_miso
413            << std::endl;
414        std::cout << "         r_spi_shiftreg: " << std::hex << (int)r_spi_shiftreg
415            << " r_spi_bitcount: " << (int)r_spi_bitcount
416            << std::endl;
417        }
418}
419}} // end namespace
420
421// Local Variables:
422// tab-width: 4
423// c-basic-offset: 4
424// c-file-offsets:((innamespace . 0)(inline-open . 0))
425// indent-tabs-mode: nil
426// End:
427
428// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
429
Note: See TracBrowser for help on using the repository browser.