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

Last change on this file since 557 was 557, checked in by bouyer, 10 years ago

Switch to using a mealy function. This seems to be the only way to get output
signals in sync with the spi_clk in all cases.
Now this model works in cosimulation with the VHDL spi controller.

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