Root/target/linux/at91/image/dfboot/src/mci_device.c

1//*----------------------------------------------------------------------------
2//* ATMEL Microcontroller Software Support - ROUSSET -
3//*----------------------------------------------------------------------------
4//* The software is delivered "AS IS" without warranty or condition of any
5//* kind, either express, implied or statutory. This includes without
6//* limitation any warranty or condition with respect to merchantability or
7//* fitness for any particular purpose, or against the infringements of
8//* intellectual property rights of others.
9//*----------------------------------------------------------------------------
10//* File Name : mci_device.c
11//* Object : TEST DataFlash Functions
12//* Creation : FB 26/11/2002
13//*
14//*----------------------------------------------------------------------------
15
16#include <AT91C_MCI_Device.h>
17#include "stdio.h"
18
19#define AT91C_MCI_TIMEOUT 1000000 /* For AT91F_MCIDeviceWaitReady */
20#define BUFFER_SIZE_MCI_DEVICE 512
21#define MASTER_CLOCK 60000000
22#define FALSE 0
23#define TRUE 1
24
25//* External Functions
26extern void AT91F_ASM_MCI_Handler(void);
27//* Global Variables
28AT91S_MciDeviceFeatures MCI_Device_Features;
29AT91S_MciDeviceDesc MCI_Device_Desc;
30AT91S_MciDevice MCI_Device;
31
32#undef ENABLE_WRITE
33#undef MMC
34
35//*----------------------------------------------------------------------------
36//* \fn AT91F_MCI_SendCommand
37//* \brief Generic function to send a command to the MMC or SDCard
38//*----------------------------------------------------------------------------
39int AT91F_MCI_SendCommand (
40    AT91PS_MciDevice pMCI_Device,
41    unsigned int Cmd,
42    unsigned int Arg)
43{
44    unsigned int error,status;
45    //unsigned int tick=0;
46
47    // Send the command
48    AT91C_BASE_MCI->MCI_ARGR = Arg;
49    AT91C_BASE_MCI->MCI_CMDR = Cmd;
50
51    // wait for CMDRDY Status flag to read the response
52    do
53    {
54        status = AT91C_BASE_MCI->MCI_SR;
55        //tick++;
56    }
57    while( !(status & AT91C_MCI_CMDRDY) );//&& (tick<100) );
58
59    // Test error ==> if crc error and response R3 ==> don't check error
60    error = (AT91C_BASE_MCI->MCI_SR) & AT91C_MCI_SR_ERROR;
61    if(error != 0 )
62    {
63        // if the command is SEND_OP_COND the CRC error flag is always present (cf : R3 response)
64        if ( (Cmd != AT91C_SDCARD_APP_OP_COND_CMD) && (Cmd != AT91C_MMC_SEND_OP_COND_CMD) )
65            return ((AT91C_BASE_MCI->MCI_SR) & AT91C_MCI_SR_ERROR);
66        else
67        {
68            if (error != AT91C_MCI_RCRCE)
69                return ((AT91C_BASE_MCI->MCI_SR) & AT91C_MCI_SR_ERROR);
70        }
71    }
72    return AT91C_CMD_SEND_OK;
73}
74
75//*----------------------------------------------------------------------------
76//* \fn AT91F_MCI_SDCard_SendAppCommand
77//* \brief Specific function to send a specific command to the SDCard
78//*----------------------------------------------------------------------------
79int AT91F_MCI_SDCard_SendAppCommand (
80    AT91PS_MciDevice pMCI_Device,
81    unsigned int Cmd_App,
82    unsigned int Arg )
83{
84    unsigned int status;
85    //unsigned int tick=0;
86
87    // Send the CMD55 for application specific command
88    AT91C_BASE_MCI->MCI_ARGR = (pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address << 16 );
89    AT91C_BASE_MCI->MCI_CMDR = AT91C_APP_CMD;
90
91    // wait for CMDRDY Status flag to read the response
92    do
93    {
94        status = AT91C_BASE_MCI->MCI_SR;
95        //tick++;
96    }
97    while( !(status & AT91C_MCI_CMDRDY) );//&& (tick<100) );
98
99    // if an error occurs
100    if (((AT91C_BASE_MCI->MCI_SR) & AT91C_MCI_SR_ERROR) != 0 )
101        return ((AT91C_BASE_MCI->MCI_SR) & AT91C_MCI_SR_ERROR);
102
103    // check if it is a specific command and then send the command
104    if ( (Cmd_App && AT91C_SDCARD_APP_ALL_CMD) == 0)
105        return AT91C_CMD_SEND_ERROR;
106
107   return( AT91F_MCI_SendCommand(pMCI_Device,Cmd_App,Arg) );
108}
109
110//*----------------------------------------------------------------------------
111//* \fn AT91F_MCI_GetStatus
112//* \brief Addressed card sends its status register
113//*----------------------------------------------------------------------------
114int AT91F_MCI_GetStatus(AT91PS_MciDevice pMCI_Device,unsigned int relative_card_address)
115{
116    if (AT91F_MCI_SendCommand(pMCI_Device,
117                                AT91C_SEND_STATUS_CMD,
118                                relative_card_address <<16) == AT91C_CMD_SEND_OK)
119        return (AT91C_BASE_MCI->MCI_RSPR[0]);
120
121    return AT91C_CMD_SEND_ERROR;
122}
123
124//*----------------------------------------------------------------------------
125//* \fn AT91F_MCI_Device_Handler
126//* \brief MCI C interrupt handler
127//*----------------------------------------------------------------------------
128void AT91F_MCI_Device_Handler(
129    AT91PS_MciDevice pMCI_Device,
130    unsigned int status)
131{
132    // If End of Tx Buffer Empty interrupt occurred
133    if ( status & AT91C_MCI_TXBUFE )
134    {
135        AT91C_BASE_MCI->MCI_IDR = AT91C_MCI_TXBUFE;
136         AT91C_BASE_PDC_MCI->PDC_PTCR = AT91C_PDC_TXTDIS;
137            
138        pMCI_Device->pMCI_DeviceDesc->state = AT91C_MCI_IDLE;
139    } // End of if AT91C_MCI_TXBUFF
140    
141    // If End of Rx Buffer Full interrupt occurred
142    if ( status & AT91C_MCI_RXBUFF )
143    {
144           AT91C_BASE_MCI->MCI_IDR = AT91C_MCI_RXBUFF;
145         AT91C_BASE_PDC_MCI->PDC_PTCR = AT91C_PDC_RXTDIS;
146    
147        pMCI_Device->pMCI_DeviceDesc->state = AT91C_MCI_IDLE;
148    } // End of if AT91C_MCI_RXBUFF
149
150}
151
152//*----------------------------------------------------------------------------
153//* \fn AT91F_MCI_Handler
154//* \brief MCI Handler
155//*----------------------------------------------------------------------------
156void AT91F_MCI_Handler(void)
157{
158    int status;
159
160    status = ( AT91C_BASE_MCI->MCI_SR & AT91C_BASE_MCI->MCI_IMR );
161
162    AT91F_MCI_Device_Handler(&MCI_Device,status);
163}
164
165//*----------------------------------------------------------------------------
166//* \fn AT91F_MCI_ReadBlock
167//* \brief Read an ENTIRE block or PARTIAL block
168//*----------------------------------------------------------------------------
169int AT91F_MCI_ReadBlock(
170    AT91PS_MciDevice pMCI_Device,
171    int src,
172    unsigned int *dataBuffer,
173    int sizeToRead )
174{
175    ////////////////////////////////////////////////////////////////////////////////////////////
176    if(pMCI_Device->pMCI_DeviceDesc->state != AT91C_MCI_IDLE)
177        return AT91C_READ_ERROR;
178    
179    if( (AT91F_MCI_GetStatus(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address) & AT91C_SR_READY_FOR_DATA) != AT91C_SR_READY_FOR_DATA)
180        return AT91C_READ_ERROR;
181        
182    if ( (src + sizeToRead) > pMCI_Device->pMCI_DeviceFeatures->Memory_Capacity )
183        return AT91C_READ_ERROR;
184
185    // If source does not fit a begin of a block
186    if ( (src % pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length) != 0 )
187        return AT91C_READ_ERROR;
188   
189     // Test if the MMC supports Partial Read Block
190     // ALWAYS SUPPORTED IN SD Memory Card
191     if( (sizeToRead < pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length)
192        && (pMCI_Device->pMCI_DeviceFeatures->Read_Partial == 0x00) )
193           return AT91C_READ_ERROR;
194           
195    if( sizeToRead > pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length)
196           return AT91C_READ_ERROR;
197    ////////////////////////////////////////////////////////////////////////////////////////////
198      
199    // Init Mode Register
200    AT91C_BASE_MCI->MCI_MR |= ((pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length << 16) | AT91C_MCI_PDCMODE);
201     
202    if (sizeToRead %4)
203        sizeToRead = (sizeToRead /4)+1;
204    else
205        sizeToRead = sizeToRead/4;
206
207    AT91C_BASE_PDC_MCI->PDC_PTCR = (AT91C_PDC_TXTDIS | AT91C_PDC_RXTDIS);
208    AT91C_BASE_PDC_MCI->PDC_RPR = (unsigned int)dataBuffer;
209    AT91C_BASE_PDC_MCI->PDC_RCR = sizeToRead;
210
211    // Send the Read single block command
212    if ( AT91F_MCI_SendCommand(pMCI_Device, AT91C_READ_SINGLE_BLOCK_CMD, src) != AT91C_CMD_SEND_OK )
213        return AT91C_READ_ERROR;
214
215    pMCI_Device->pMCI_DeviceDesc->state = AT91C_MCI_RX_SINGLE_BLOCK;
216
217    // Enable AT91C_MCI_RXBUFF Interrupt
218    AT91C_BASE_MCI->MCI_IER = AT91C_MCI_RXBUFF;
219
220    // (PDC) Receiver Transfer Enable
221    AT91C_BASE_PDC_MCI->PDC_PTCR = AT91C_PDC_RXTEN;
222    
223    return AT91C_READ_OK;
224}
225
226
227#ifdef ENABLE_WRITE
228//*----------------------------------------------------------------------------
229//* \fn AT91F_MCI_WriteBlock
230//* \brief Write an ENTIRE block but not always PARTIAL block !!!
231//*----------------------------------------------------------------------------
232int AT91F_MCI_WriteBlock(
233    AT91PS_MciDevice pMCI_Device,
234    int dest,
235    unsigned int *dataBuffer,
236    int sizeToWrite )
237{
238    ////////////////////////////////////////////////////////////////////////////////////////////
239    if( pMCI_Device->pMCI_DeviceDesc->state != AT91C_MCI_IDLE)
240        return AT91C_WRITE_ERROR;
241    
242    if( (AT91F_MCI_GetStatus(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address) & AT91C_SR_READY_FOR_DATA) != AT91C_SR_READY_FOR_DATA)
243        return AT91C_WRITE_ERROR;
244        
245    if ( (dest + sizeToWrite) > pMCI_Device->pMCI_DeviceFeatures->Memory_Capacity )
246        return AT91C_WRITE_ERROR;
247
248    // If source does not fit a begin of a block
249    if ( (dest % pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length) != 0 )
250        return AT91C_WRITE_ERROR;
251   
252    // Test if the MMC supports Partial Write Block
253    if( (sizeToWrite < pMCI_Device->pMCI_DeviceFeatures->Max_Write_DataBlock_Length)
254        && (pMCI_Device->pMCI_DeviceFeatures->Write_Partial == 0x00) )
255           return AT91C_WRITE_ERROR;
256           
257       if( sizeToWrite > pMCI_Device->pMCI_DeviceFeatures->Max_Write_DataBlock_Length )
258           return AT91C_WRITE_ERROR;
259    ////////////////////////////////////////////////////////////////////////////////////////////
260  
261    // Init Mode Register
262    AT91C_BASE_MCI->MCI_MR |= ((pMCI_Device->pMCI_DeviceFeatures->Max_Write_DataBlock_Length << 16) | AT91C_MCI_PDCMODE);
263    
264    if (sizeToWrite %4)
265        sizeToWrite = (sizeToWrite /4)+1;
266    else
267        sizeToWrite = sizeToWrite/4;
268
269    // Init PDC for write sequence
270    AT91C_BASE_PDC_MCI->PDC_PTCR = (AT91C_PDC_TXTDIS | AT91C_PDC_RXTDIS);
271    AT91C_BASE_PDC_MCI->PDC_TPR = (unsigned int) dataBuffer;
272    AT91C_BASE_PDC_MCI->PDC_TCR = sizeToWrite;
273
274    // Send the write single block command
275    if ( AT91F_MCI_SendCommand(pMCI_Device, AT91C_WRITE_BLOCK_CMD, dest) != AT91C_CMD_SEND_OK)
276        return AT91C_WRITE_ERROR;
277
278    pMCI_Device->pMCI_DeviceDesc->state = AT91C_MCI_TX_SINGLE_BLOCK;
279
280    // Enable AT91C_MCI_TXBUFE Interrupt
281    AT91C_BASE_MCI->MCI_IER = AT91C_MCI_TXBUFE;
282  
283      // Enables TX for PDC transfert requests
284    AT91C_BASE_PDC_MCI->PDC_PTCR = AT91C_PDC_TXTEN;
285  
286    return AT91C_WRITE_OK;
287}
288#endif
289
290#ifdef MMC
291//*------------------------------------------------------------------------------------------------------------
292//* \fn AT91F_MCI_MMC_SelectCard
293//* \brief Toggles a card between the Stand_by and Transfer states or between Programming and Disconnect states
294//*------------------------------------------------------------------------------------------------------------
295int AT91F_MCI_MMC_SelectCard(AT91PS_MciDevice pMCI_Device, unsigned int relative_card_address)
296{
297    int status;
298    
299    //* Check if the MMC card chosen is already the selected one
300    status = AT91F_MCI_GetStatus(pMCI_Device,relative_card_address);
301
302    if (status < 0)
303        return AT91C_CARD_SELECTED_ERROR;
304
305    if ((status & AT91C_SR_CARD_SELECTED) == AT91C_SR_CARD_SELECTED)
306        return AT91C_CARD_SELECTED_OK;
307
308    //* Search for the MMC Card to be selected, status = the Corresponding Device Number
309    status = 0;
310    while( (pMCI_Device->pMCI_DeviceFeatures[status].Relative_Card_Address != relative_card_address)
311           && (status < AT91C_MAX_MCI_CARDS) )
312        status++;
313
314    if (status > AT91C_MAX_MCI_CARDS)
315        return AT91C_CARD_SELECTED_ERROR;
316
317    if (AT91F_MCI_SendCommand( pMCI_Device,
318                                       AT91C_SEL_DESEL_CARD_CMD,
319                                       pMCI_Device->pMCI_DeviceFeatures[status].Relative_Card_Address << 16) == AT91C_CMD_SEND_OK)
320        return AT91C_CARD_SELECTED_OK;
321    return AT91C_CARD_SELECTED_ERROR;
322}
323#endif
324
325//*----------------------------------------------------------------------------
326//* \fn AT91F_MCI_GetCSD
327//* \brief Asks to the specified card to send its CSD
328//*----------------------------------------------------------------------------
329int AT91F_MCI_GetCSD (AT91PS_MciDevice pMCI_Device, unsigned int relative_card_address , unsigned int * response)
330{
331     
332     if(AT91F_MCI_SendCommand(pMCI_Device,
333                                  AT91C_SEND_CSD_CMD,
334                                  (relative_card_address << 16)) != AT91C_CMD_SEND_OK)
335        return AT91C_CMD_SEND_ERROR;
336    
337    response[0] = AT91C_BASE_MCI->MCI_RSPR[0];
338       response[1] = AT91C_BASE_MCI->MCI_RSPR[1];
339    response[2] = AT91C_BASE_MCI->MCI_RSPR[2];
340    response[3] = AT91C_BASE_MCI->MCI_RSPR[3];
341    
342    return AT91C_CMD_SEND_OK;
343}
344
345//*----------------------------------------------------------------------------
346//* \fn AT91F_MCI_SetBlocklength
347//* \brief Select a block length for all following block commands (R/W)
348//*----------------------------------------------------------------------------
349int AT91F_MCI_SetBlocklength(AT91PS_MciDevice pMCI_Device,unsigned int length)
350{
351    return( AT91F_MCI_SendCommand(pMCI_Device, AT91C_SET_BLOCKLEN_CMD, length) );
352}
353
354#ifdef MMC
355//*----------------------------------------------------------------------------
356//* \fn AT91F_MCI_MMC_GetAllOCR
357//* \brief Asks to all cards to send their operations conditions
358//*----------------------------------------------------------------------------
359int AT91F_MCI_MMC_GetAllOCR (AT91PS_MciDevice pMCI_Device)
360{
361    unsigned int response =0x0;
362     
363     while(1)
364    {
365        response = AT91F_MCI_SendCommand(pMCI_Device,
366                                          AT91C_MMC_SEND_OP_COND_CMD,
367                                          AT91C_MMC_HOST_VOLTAGE_RANGE);
368        if (response != AT91C_CMD_SEND_OK)
369            return AT91C_INIT_ERROR;
370        
371        response = AT91C_BASE_MCI->MCI_RSPR[0];
372        
373        if ( (response & AT91C_CARD_POWER_UP_BUSY) == AT91C_CARD_POWER_UP_BUSY)
374            return(response);
375    }
376}
377#endif
378
379#ifdef MMC
380//*----------------------------------------------------------------------------
381//* \fn AT91F_MCI_MMC_GetAllCID
382//* \brief Asks to the MMC on the chosen slot to send its CID
383//*----------------------------------------------------------------------------
384int AT91F_MCI_MMC_GetAllCID (AT91PS_MciDevice pMCI_Device, unsigned int *response)
385{
386    int Nb_Cards_Found=-1;
387  
388    while(1)
389    {
390         if(AT91F_MCI_SendCommand(pMCI_Device,
391                                AT91C_MMC_ALL_SEND_CID_CMD,
392                                AT91C_NO_ARGUMENT) != AT91C_CMD_SEND_OK)
393            return Nb_Cards_Found;
394        else
395        {
396            Nb_Cards_Found = 0;
397            //* Assignation of the relative address to the MMC CARD
398            pMCI_Device->pMCI_DeviceFeatures[Nb_Cards_Found].Relative_Card_Address = Nb_Cards_Found + AT91C_FIRST_RCA;
399            //* Set the insert flag
400            pMCI_Device->pMCI_DeviceFeatures[Nb_Cards_Found].Card_Inserted = AT91C_MMC_CARD_INSERTED;
401    
402            if (AT91F_MCI_SendCommand(pMCI_Device,
403                                     AT91C_MMC_SET_RELATIVE_ADDR_CMD,
404                                     (Nb_Cards_Found + AT91C_FIRST_RCA) << 16) != AT91C_CMD_SEND_OK)
405                return AT91C_CMD_SEND_ERROR;
406                 
407            //* If no error during assignation address ==> Increment Nb_cards_Found
408            Nb_Cards_Found++ ;
409        }
410    }
411}
412#endif
413#ifdef MMC
414//*----------------------------------------------------------------------------
415//* \fn AT91F_MCI_MMC_Init
416//* \brief Return the MMC initialisation status
417//*----------------------------------------------------------------------------
418int AT91F_MCI_MMC_Init (AT91PS_MciDevice pMCI_Device)
419{
420    unsigned int tab_response[4];
421    unsigned int mult,blocknr;
422    unsigned int i,Nb_Cards_Found=0;
423
424    //* Resets all MMC Cards in Idle state
425    AT91F_MCI_SendCommand(pMCI_Device, AT91C_MMC_GO_IDLE_STATE_CMD, AT91C_NO_ARGUMENT);
426
427    if(AT91F_MCI_MMC_GetAllOCR(pMCI_Device) == AT91C_INIT_ERROR)
428        return AT91C_INIT_ERROR;
429
430    Nb_Cards_Found = AT91F_MCI_MMC_GetAllCID(pMCI_Device,tab_response);
431    if (Nb_Cards_Found != AT91C_CMD_SEND_ERROR)
432    {
433        //* Set the Mode Register
434        AT91C_BASE_MCI->MCI_MR = AT91C_MCI_MR_PDCMODE;
435
436        for(i = 0; i < Nb_Cards_Found; i++)
437        {
438            if (AT91F_MCI_GetCSD(pMCI_Device,
439                                      pMCI_Device->pMCI_DeviceFeatures[i].Relative_Card_Address,
440                                      tab_response) != AT91C_CMD_SEND_OK)
441                pMCI_Device->pMCI_DeviceFeatures[i].Relative_Card_Address = 0;
442            else
443            {
444                pMCI_Device->pMCI_DeviceFeatures[i].Max_Read_DataBlock_Length = 1 << ((tab_response[1] >> AT91C_CSD_RD_B_LEN_S) & AT91C_CSD_RD_B_LEN_M );
445                 pMCI_Device->pMCI_DeviceFeatures[i].Max_Write_DataBlock_Length = 1 << ((tab_response[3] >> AT91C_CSD_WBLEN_S) & AT91C_CSD_WBLEN_M );
446                pMCI_Device->pMCI_DeviceFeatures[i].Sector_Size = 1 + ((tab_response[2] >> AT91C_CSD_v22_SECT_SIZE_S) & AT91C_CSD_v22_SECT_SIZE_M );
447                  pMCI_Device->pMCI_DeviceFeatures[i].Read_Partial = (tab_response[1] >> AT91C_CSD_RD_B_PAR_S) & AT91C_CSD_RD_B_PAR_M;
448                pMCI_Device->pMCI_DeviceFeatures[i].Write_Partial = (tab_response[3] >> AT91C_CSD_WBLOCK_P_S) & AT91C_CSD_WBLOCK_P_M;
449                
450                // None in MMC specification version 2.2
451                pMCI_Device->pMCI_DeviceFeatures[i].Erase_Block_Enable = 0;
452                
453                pMCI_Device->pMCI_DeviceFeatures[i].Read_Block_Misalignment = (tab_response[1] >> AT91C_CSD_RD_B_MIS_S) & AT91C_CSD_RD_B_MIS_M;
454                pMCI_Device->pMCI_DeviceFeatures[i].Write_Block_Misalignment = (tab_response[1] >> AT91C_CSD_WR_B_MIS_S) & AT91C_CSD_WR_B_MIS_M;
455
456                //// Compute Memory Capacity
457                // compute MULT
458                mult = 1 << ( ((tab_response[2] >> AT91C_CSD_C_SIZE_M_S) & AT91C_CSD_C_SIZE_M_M) + 2 );
459                // compute MSB of C_SIZE
460                blocknr = ((tab_response[1] >> AT91C_CSD_CSIZE_H_S) & AT91C_CSD_CSIZE_H_M) << 2;
461                // compute MULT * (LSB of C-SIZE + MSB already computed + 1) = BLOCKNR
462                blocknr = mult * ( ( blocknr + ( (tab_response[2] >> AT91C_CSD_CSIZE_L_S) & AT91C_CSD_CSIZE_L_M) ) + 1 );
463
464                pMCI_Device->pMCI_DeviceFeatures[i].Memory_Capacity = pMCI_Device->pMCI_DeviceFeatures[i].Max_Read_DataBlock_Length * blocknr;
465                  //// End of Compute Memory Capacity
466                  
467            } // end of else
468        } // end of for
469        
470        return AT91C_INIT_OK;
471    } // end of if
472
473    return AT91C_INIT_ERROR;
474}
475#endif
476
477//*----------------------------------------------------------------------------
478//* \fn AT91F_MCI_SDCard_GetOCR
479//* \brief Asks to all cards to send their operations conditions
480//*----------------------------------------------------------------------------
481int AT91F_MCI_SDCard_GetOCR (AT91PS_MciDevice pMCI_Device)
482{
483    unsigned int response =0x0;
484
485    // The RCA to be used for CMD55 in Idle state shall be the card's default RCA=0x0000.
486    pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address = 0x0;
487     
488     while( (response & AT91C_CARD_POWER_UP_BUSY) != AT91C_CARD_POWER_UP_BUSY )
489    {
490        response = AT91F_MCI_SDCard_SendAppCommand(pMCI_Device,
491                                          AT91C_SDCARD_APP_OP_COND_CMD,
492                                          AT91C_MMC_HOST_VOLTAGE_RANGE);
493        if (response != AT91C_CMD_SEND_OK)
494            return AT91C_INIT_ERROR;
495        
496        response = AT91C_BASE_MCI->MCI_RSPR[0];
497    }
498    
499    return(AT91C_BASE_MCI->MCI_RSPR[0]);
500}
501
502//*----------------------------------------------------------------------------
503//* \fn AT91F_MCI_SDCard_GetCID
504//* \brief Asks to the SDCard on the chosen slot to send its CID
505//*----------------------------------------------------------------------------
506int AT91F_MCI_SDCard_GetCID (AT91PS_MciDevice pMCI_Device, unsigned int *response)
507{
508     if(AT91F_MCI_SendCommand(pMCI_Device,
509                            AT91C_ALL_SEND_CID_CMD,
510                            AT91C_NO_ARGUMENT) != AT91C_CMD_SEND_OK)
511        return AT91C_CMD_SEND_ERROR;
512    
513    response[0] = AT91C_BASE_MCI->MCI_RSPR[0];
514       response[1] = AT91C_BASE_MCI->MCI_RSPR[1];
515    response[2] = AT91C_BASE_MCI->MCI_RSPR[2];
516    response[3] = AT91C_BASE_MCI->MCI_RSPR[3];
517    
518    return AT91C_CMD_SEND_OK;
519}
520
521//*----------------------------------------------------------------------------
522//* \fn AT91F_MCI_SDCard_SetBusWidth
523//* \brief Set bus width for SDCard
524//*----------------------------------------------------------------------------
525int AT91F_MCI_SDCard_SetBusWidth(AT91PS_MciDevice pMCI_Device)
526{
527    volatile int ret_value;
528    char bus_width;
529
530    do
531    {
532        ret_value =AT91F_MCI_GetStatus(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address);
533    }
534    while((ret_value > 0) && ((ret_value & AT91C_SR_READY_FOR_DATA) == 0));
535
536    // Select Card
537    AT91F_MCI_SendCommand(pMCI_Device,
538                            AT91C_SEL_DESEL_CARD_CMD,
539                            (pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address)<<16);
540
541    // Set bus width for Sdcard
542    if(pMCI_Device->pMCI_DeviceDesc->SDCard_bus_width == AT91C_MCI_SCDBUS)
543             bus_width = AT91C_BUS_WIDTH_4BITS;
544    else bus_width = AT91C_BUS_WIDTH_1BIT;
545
546    if (AT91F_MCI_SDCard_SendAppCommand(pMCI_Device,AT91C_SDCARD_SET_BUS_WIDTH_CMD,bus_width) != AT91C_CMD_SEND_OK)
547        return AT91C_CMD_SEND_ERROR;
548
549    return AT91C_CMD_SEND_OK;
550}
551
552//*----------------------------------------------------------------------------
553//* \fn AT91F_MCI_SDCard_Init
554//* \brief Return the SDCard initialisation status
555//*----------------------------------------------------------------------------
556int AT91F_MCI_SDCard_Init (AT91PS_MciDevice pMCI_Device)
557{
558    unsigned int tab_response[4];
559    unsigned int mult,blocknr;
560
561    AT91F_MCI_SendCommand(pMCI_Device, AT91C_GO_IDLE_STATE_CMD, AT91C_NO_ARGUMENT);
562
563    if(AT91F_MCI_SDCard_GetOCR(pMCI_Device) == AT91C_INIT_ERROR)
564        return AT91C_INIT_ERROR;
565
566    if (AT91F_MCI_SDCard_GetCID(pMCI_Device,tab_response) == AT91C_CMD_SEND_OK)
567    {
568        pMCI_Device->pMCI_DeviceFeatures->Card_Inserted = AT91C_SD_CARD_INSERTED;
569
570        if (AT91F_MCI_SendCommand(pMCI_Device, AT91C_SET_RELATIVE_ADDR_CMD, 0) == AT91C_CMD_SEND_OK)
571        {
572            pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address = (AT91C_BASE_MCI->MCI_RSPR[0] >> 16);
573            if (AT91F_MCI_GetCSD(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Relative_Card_Address,tab_response) == AT91C_CMD_SEND_OK)
574            {
575                  pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length = 1 << ((tab_response[1] >> AT91C_CSD_RD_B_LEN_S) & AT91C_CSD_RD_B_LEN_M );
576                 pMCI_Device->pMCI_DeviceFeatures->Max_Write_DataBlock_Length = 1 << ((tab_response[3] >> AT91C_CSD_WBLEN_S) & AT91C_CSD_WBLEN_M );
577                pMCI_Device->pMCI_DeviceFeatures->Sector_Size = 1 + ((tab_response[2] >> AT91C_CSD_v21_SECT_SIZE_S) & AT91C_CSD_v21_SECT_SIZE_M );
578                  pMCI_Device->pMCI_DeviceFeatures->Read_Partial = (tab_response[1] >> AT91C_CSD_RD_B_PAR_S) & AT91C_CSD_RD_B_PAR_M;
579                pMCI_Device->pMCI_DeviceFeatures->Write_Partial = (tab_response[3] >> AT91C_CSD_WBLOCK_P_S) & AT91C_CSD_WBLOCK_P_M;
580                pMCI_Device->pMCI_DeviceFeatures->Erase_Block_Enable = (tab_response[3] >> AT91C_CSD_v21_ER_BLEN_EN_S) & AT91C_CSD_v21_ER_BLEN_EN_M;
581                pMCI_Device->pMCI_DeviceFeatures->Read_Block_Misalignment = (tab_response[1] >> AT91C_CSD_RD_B_MIS_S) & AT91C_CSD_RD_B_MIS_M;
582                pMCI_Device->pMCI_DeviceFeatures->Write_Block_Misalignment = (tab_response[1] >> AT91C_CSD_WR_B_MIS_S) & AT91C_CSD_WR_B_MIS_M;
583
584                //// Compute Memory Capacity
585                    // compute MULT
586                    mult = 1 << ( ((tab_response[2] >> AT91C_CSD_C_SIZE_M_S) & AT91C_CSD_C_SIZE_M_M) + 2 );
587                    // compute MSB of C_SIZE
588                    blocknr = ((tab_response[1] >> AT91C_CSD_CSIZE_H_S) & AT91C_CSD_CSIZE_H_M) << 2;
589                    // compute MULT * (LSB of C-SIZE + MSB already computed + 1) = BLOCKNR
590                    blocknr = mult * ( ( blocknr + ( (tab_response[2] >> AT91C_CSD_CSIZE_L_S) & AT91C_CSD_CSIZE_L_M) ) + 1 );
591
592                    pMCI_Device->pMCI_DeviceFeatures->Memory_Capacity = pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length * blocknr;
593                  //// End of Compute Memory Capacity
594                    printf("SD-Card: %d Bytes\n\r", pMCI_Device->pMCI_DeviceFeatures->Memory_Capacity);
595
596                  if( AT91F_MCI_SDCard_SetBusWidth(pMCI_Device) == AT91C_CMD_SEND_OK )
597                {
598                     if (AT91F_MCI_SetBlocklength(pMCI_Device,pMCI_Device->pMCI_DeviceFeatures->Max_Read_DataBlock_Length) == AT91C_CMD_SEND_OK)
599                    return AT91C_INIT_OK;
600                }
601            }
602        }
603    }
604    return AT91C_INIT_ERROR;
605}
606
607//*----------------------------------------------------------------------------
608//* \fn AT91F_CfgDevice
609//* \brief This function is used to initialise MMC or SDCard Features
610//*----------------------------------------------------------------------------
611void AT91F_CfgDevice(void)
612{
613    // Init Device Structure
614
615    MCI_Device_Features.Relative_Card_Address = 0;
616    MCI_Device_Features.Card_Inserted = AT91C_CARD_REMOVED;
617    MCI_Device_Features.Max_Read_DataBlock_Length = 0;
618    MCI_Device_Features.Max_Write_DataBlock_Length = 0;
619    MCI_Device_Features.Read_Partial = 0;
620    MCI_Device_Features.Write_Partial = 0;
621    MCI_Device_Features.Erase_Block_Enable = 0;
622    MCI_Device_Features.Sector_Size = 0;
623    MCI_Device_Features.Memory_Capacity = 0;
624    
625    MCI_Device_Desc.state = AT91C_MCI_IDLE;
626    MCI_Device_Desc.SDCard_bus_width = AT91C_MCI_SCDBUS;
627    
628    // Init AT91S_DataFlash Global Structure, by default AT45DB choosen !!!
629    MCI_Device.pMCI_DeviceDesc = &MCI_Device_Desc;
630    MCI_Device.pMCI_DeviceFeatures = &MCI_Device_Features;
631
632}
633
634//*----------------------------------------------------------------------------
635//* \fn AT91F_MCI_Init
636//* \brief Initialsise Card
637//*----------------------------------------------------------------------------
638int AT91F_MCI_Init(void)
639{
640
641///////////////////////////////////////////////////////////////////////////////////////////
642// MCI Init : common to MMC and SDCard
643///////////////////////////////////////////////////////////////////////////////////////////
644
645    // Set up PIO SDC_TYPE to switch on MMC/SDCard and not DataFlash Card
646    AT91F_PIO_CfgOutput(AT91C_BASE_PIOB,AT91C_PIO_PB7);
647    AT91F_PIO_SetOutput(AT91C_BASE_PIOB,AT91C_PIO_PB7);
648    
649    // Init MCI for MMC and SDCard interface
650    AT91F_MCI_CfgPIO();
651    AT91F_MCI_CfgPMC();
652    AT91F_PDC_Open(AT91C_BASE_PDC_MCI);
653
654    // Disable all the interrupts
655    AT91C_BASE_MCI->MCI_IDR = 0xFFFFFFFF;
656
657    // Init MCI Device Structures
658    AT91F_CfgDevice();
659
660    // Configure MCI interrupt
661    AT91F_AIC_ConfigureIt(AT91C_BASE_AIC,
662                         AT91C_ID_MCI,
663                         AT91C_AIC_PRIOR_HIGHEST,
664                         AT91C_AIC_SRCTYPE_INT_LEVEL_SENSITIVE,
665                         AT91F_ASM_MCI_Handler);
666
667    // Enable MCI interrupt
668    AT91F_AIC_EnableIt(AT91C_BASE_AIC,AT91C_ID_MCI);
669
670    // Enable Receiver
671    AT91F_US_EnableRx((AT91PS_USART) AT91C_BASE_DBGU);
672
673    AT91F_MCI_Configure(AT91C_BASE_MCI,
674                        AT91C_MCI_DTOR_1MEGA_CYCLES,
675                        AT91C_MCI_MR_PDCMODE, // 15MHz for MCK = 60MHz (CLKDIV = 1)
676                        AT91C_MCI_SDCARD_4BITS_SLOTA);
677    
678    if(AT91F_MCI_SDCard_Init(&MCI_Device) != AT91C_INIT_OK)
679        return FALSE;
680    else
681        return TRUE;
682
683}
684
685//*----------------------------------------------------------------------------
686//* \fn AT91F_MCIDeviceWaitReady
687//* \brief Wait for MCI Device ready
688//*----------------------------------------------------------------------------
689void AT91F_MCIDeviceWaitReady(unsigned int timeout)
690{
691    volatile int status;
692    
693    do
694    {
695        status = AT91C_BASE_MCI->MCI_SR;
696        timeout--;
697    }
698    while( !(status & AT91C_MCI_NOTBUSY) && (timeout>0) );
699}
700
701unsigned int swab32(unsigned int data)
702{
703    unsigned int res = 0;
704
705    res = (data & 0x000000ff) << 24 |
706                (data & 0x0000ff00) << 8 |
707                (data & 0x00ff0000) >> 8 |
708                (data & 0xff000000) >> 24;
709
710    return res;
711}
712
713//*--------------------------------------------------------------------
714//* \fn AT91F_MCI_ReadBlockSwab
715//* \brief Read Block and swap byte order
716//*--------------------------------------------------------------------
717int AT91F_MCI_ReadBlockSwab(
718    AT91PS_MciDevice pMCI_Device,
719    int src,
720    unsigned int *databuffer,
721    int sizeToRead)
722{
723    int i;
724    unsigned char *buf = (unsigned char *)databuffer;
725
726    //* Read Block 1
727    for(i=0;i<BUFFER_SIZE_MCI_DEVICE;i++)
728        *buf++ = 0x00;
729    AT91F_MCI_ReadBlock(&MCI_Device,src,databuffer,sizeToRead);
730
731    //* Wait end of Read
732    AT91F_MCIDeviceWaitReady(AT91C_MCI_TIMEOUT);
733
734    {
735        int index;
736        unsigned int *uiBuffer = databuffer;
737
738        for(index = 0; index < 512/4; index++)
739            uiBuffer[index] = swab32(uiBuffer[index]);
740    }
741    return(1);
742}
743
744

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive