Vekatech
SDHI_driver patch (mbedOS 5.11.5)
Embed:
(wiki syntax)
Show/hide line numbers
sdhi_low.c
00001 /******************************************************************************* 00002 * DISCLAIMER 00003 * This software is supplied by Renesas Electronics Corporation and is only 00004 * intended for use with Renesas products. No other uses are authorized. This 00005 * software is owned by Renesas Electronics Corporation and is protected under 00006 * all applicable laws, including copyright laws. 00007 * THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING 00008 * THIS SOFTWARE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING BUT NOT 00009 * LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE 00010 * AND NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED. 00011 * TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY LAW, NEITHER RENESAS 00012 * ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE 00013 * FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR 00014 * ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR ITS AFFILIATES HAVE 00015 * BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 00016 * Renesas reserves the right, without notice, to make changes to this software 00017 * and to discontinue the availability of this software. By using this software, 00018 * you agree to the additional terms and conditions found by accessing the 00019 * following link: 00020 * http://www.renesas.com/disclaimer 00021 * 00022 * Copyright (C) 2013 Renesas Electronics Corporation. All rights reserved. 00023 *******************************************************************************/ 00024 /******************************************************************************* 00025 * File Name : sd_dev_low.c 00026 * $Rev: $ 00027 * $Date:: $ 00028 * Device(s) : RZ/A1H 00029 * Tool-Chain : DS-5 Ver 5.8 00030 * : ARM Complier 00031 * OS : 00032 * H/W Platform : RZ/A1H CPU Board 00033 * Description : RZ/A1H SD Driver Sample Program 00034 * Operation : 00035 * Limitations : 00036 *******************************************************************************/ 00037 00038 00039 /****************************************************************************** 00040 Includes <System Includes> , "Project Includes" 00041 ******************************************************************************/ 00042 #include <stdio.h> 00043 #include <string.h> 00044 #include "r_typedefs.h" 00045 #include "iodefine.h" 00046 #include "rza_io_regrw.h" 00047 /*#include "devdrv_intc.h"*/ 00048 #include "sdif.h" 00049 #include "sd_cfg.h" 00050 /*#include "sd_dev_dmacdrv.h"*/ 00051 #include "us_ticker_api.h" 00052 #include "cmsis_os2.h" 00053 #include "mbed_assert.h" 00054 #include "pinmap.h" 00055 00056 00057 /****************************************************************************** 00058 Typedef definitions 00059 ******************************************************************************/ 00060 00061 00062 /****************************************************************************** 00063 Macro definitions 00064 ******************************************************************************/ 00065 //#define MTU_TIMER_CNT 32 /* P-phy = 32MHz */ 00066 #define INT_LEVEL_SDHI 10 /* SDHI interrupt level */ 00067 #define SDHI_PINS_COMMON 2 00068 #define SDHI_PINS_SERIAL 3 00069 #define SDHI_PINS_PARALLEL 6 00070 00071 #if defined(SDCFG_SDMODE_1BIT) 00072 # define SDHI_PORT_MODE SD_PORT_SERIAL 00073 #else 00074 # define SDHI_PORT_MODE SD_PORT_PARALLEL 00075 #endif 00076 00077 /****************************************************************************** 00078 Imported global variables and functions (from other files) 00079 ******************************************************************************/ 00080 00081 00082 /****************************************************************************** 00083 Exported global variables and functions (to be accessed by other files) 00084 ******************************************************************************/ 00085 00086 00087 /****************************************************************************** 00088 Private global variables and functions 00089 ******************************************************************************/ 00090 #if 0 00091 static uint8_t g_sdhi_priority_backup; 00092 #endif 00093 00094 00095 00096 static const PinName SDHIpin_Common[SDHI_COUNT][SDHI_PINS_COMMON] = { /* WP & CD */ 00097 #if defined(TARGET_VK_RZ_A1H) 00098 {P4_8, P4_9}, 00099 {P3_8, P3_9} 00100 #elif defined(TARGET_VK_RZ_A1LU) 00101 {P3_6, P3_7}, 00102 {P7_1, P7_0} 00103 #else 00104 #error RZ_SDHI driver does not support this TARGET 00105 #endif 00106 }; 00107 00108 static const PinName SDHIpin_serial[SDHI_COUNT][SDHI_PINS_SERIAL] = { /* CLK CMD D0 */ 00109 #if defined(TARGET_VK_RZ_A1H) 00110 {P4_11, P4_12, P4_13}, 00111 {P3_11, P3_12, P3_13} 00112 #elif defined(TARGET_VK_RZ_A1LU) 00113 {P3_3, P3_2, P3_4}, 00114 {P7_4, P7_5, P7_3} 00115 #else 00116 #error RZ_SDHI driver does not support this TARGET 00117 #endif 00118 }; 00119 00120 static const PinName SDHIpin_parallel[SDHI_COUNT][SDHI_PINS_PARALLEL] = { /* CLK CMD D0-D3 */ 00121 #if defined(TARGET_VK_RZ_A1H) 00122 {P4_10, P4_11, P4_12, P4_13, P4_14, P4_15}, 00123 {P3_10, P3_11, P3_12, P3_13, P3_14, P3_15} 00124 #elif defined(TARGET_VK_RZ_A1LU) 00125 {P3_3, P3_2, P3_4, P3_5, P3_0, P3_1}, 00126 {P7_4, P7_5, P7_3, P7_2, P7_7, P7_6} 00127 #else 00128 #error RZ_SDHI driver does not support this TARGET 00129 #endif 00130 }; 00131 00132 00133 static const PinMap PinMap_SDHI_PIN[] = { 00134 /* pin | periph| func */ 00135 #if defined(TARGET_VK_RZ_A1H) 00136 {P4_8 , SDHI_0, 3}, /* SD_CD_0 */ 00137 {P4_9 , SDHI_0, 3}, /* SD_WP_0 */ 00138 {P4_10 , SDHI_0, 3}, /* SD_D1_0 */ 00139 {P4_11 , SDHI_0, 3}, /* SD_D0_0 */ 00140 {P4_12 , SDHI_0, 3}, /* SD_CLK_0 */ 00141 {P4_13 , SDHI_0, 3}, /* SD_CMD_0 */ 00142 {P4_14 , SDHI_0, 3}, /* SD_D3_0 */ 00143 {P4_15 , SDHI_0, 3}, /* SD_D2_0 */ 00144 /*----------------*/ 00145 {P3_8 , SDHI_1, 7}, /* SD_CD_1 */ 00146 {P3_9 , SDHI_1, 7}, /* SD_WP_1 */ 00147 {P3_10 , SDHI_1, 7}, /* SD_D1_1 */ 00148 {P3_11 , SDHI_1, 7}, /* SD_D0_1 */ 00149 {P3_12 , SDHI_1, 7}, /* SD_CLK_1 */ 00150 {P3_13 , SDHI_1, 7}, /* SD_CMD_1 */ 00151 {P3_14 , SDHI_1, 7}, /* SD_D3_1 */ 00152 {P3_15 , SDHI_1, 7}, /* SD_D2_1 */ 00153 {NC , NC , 0} 00154 #elif defined(TARGET_VK_RZ_A1LU) 00155 //{P3_7 , SDHI_0, 2}, /* SD_CD_0 can be used if SDRAM is not soldered */ 00156 //{P3_6 , SDHI_0, 2}, /* SD_WP_0 can be used if SDRAM is not soldered */ 00157 //{P3_5 , SDHI_0, 2}, /* SD_D1_0 can be used if SDRAM is not soldered */ 00158 //{P3_4 , SDHI_0, 2}, /* SD_D0_0 can be used if SDRAM is not soldered */ 00159 //{P3_3 , SDHI_0, 2}, /* SD_CLK_0 can be used if SDRAM is not soldered */ 00160 //{P3_2 , SDHI_0, 2}, /* SD_CMD_0 can be used if SDRAM is not soldered */ 00161 //{P3_1 , SDHI_0, 2}, /* SD_D3_0 can be used if SDRAM is not soldered */ 00162 //{P3_0 , SDHI_0, 2}, /* SD_D2_0 can be used if SDRAM is not soldered */ 00163 /*----------------*/ 00164 {P7_0 , SDHI_1, 3}, /* SD_CD_1 */ 00165 {P7_1 , SDHI_1, 3}, /* SD_WP_1 */ 00166 {P7_2 , SDHI_1, 3}, /* SD_D1_1 */ 00167 {P7_3 , SDHI_1, 3}, /* SD_D0_1 */ 00168 {P7_4 , SDHI_1, 3}, /* SD_CLK_1 */ 00169 {P7_5 , SDHI_1, 3}, /* SD_CMD_1 */ 00170 {P7_6 , SDHI_1, 3}, /* SD_D3_1 */ 00171 {P7_7 , SDHI_1, 3}, /* SD_D2_1 */ 00172 {NC , NC , 0} 00173 #else 00174 #error RZ_SDHI driver does not support this TARGET 00175 #endif 00176 }; 00177 00178 00179 00180 static unsigned long _ulStart = 0; 00181 static unsigned long _ulDelta = 0; 00182 static const ticker_data_t *_ticker; 00183 00184 //static int sddev_init_0(void); 00185 //static int sddev_init_1(void); 00186 //static int sddev_set_port_0(int mode); 00187 //static int sddev_set_port_1(int mode); 00188 00189 static int sddev_init_dma_0(unsigned long buff,unsigned long reg,long cnt,int dir); 00190 static int sddev_init_dma_1(unsigned long buff,unsigned long reg,long cnt,int dir); 00191 00192 static int sddev_wait_dma_end_0(long cnt); 00193 static int sddev_wait_dma_end_1(long cnt); 00194 00195 static int sddev_disable_dma_0(void); 00196 static int sddev_disable_dma_1(void); 00197 00198 static void sddev_sd_int_handler_0(uint32_t int_sense); 00199 static void sddev_sd_int_handler_1(uint32_t int_sense); 00200 static void sddev_sdio_int_handler_0(uint32_t int_sense); 00201 static void sddev_sdio_int_handler_1(uint32_t int_sense); 00202 static void sddev_start_timer(int msec); 00203 static void sddev_end_timer(void); 00204 static int sddev_check_timer(void); 00205 00206 /****************************************************************************** 00207 * Function Name: int sddev_cmd0_sdio_mount(int sd_port); 00208 * Description : Select to issue CMD0 before SDIO Mount 00209 * Arguments : none 00210 * Return Value : SD_OK : issue CMD0 00211 * : SD_ERR : not issue CMD0 00212 ******************************************************************************/ 00213 int sddev_cmd0_sdio_mount(int sd_port) 00214 { 00215 #ifdef SDCFG_IO 00216 return SD_ERR; 00217 #else 00218 return SD_ERR; 00219 #endif 00220 } 00221 00222 /****************************************************************************** 00223 * Function Name: int sddev_cmd8_sdio_mount(int sd_port); 00224 * Description : Select to issue CMD8 before SDIO Mount 00225 * Arguments : none 00226 * Return Value : SD_OK : issue CMD8 00227 * : SD_ERR : not issue CMD8 00228 ******************************************************************************/ 00229 int sddev_cmd8_sdio_mount(int sd_port) 00230 { 00231 #ifdef SDCFG_IO 00232 return SD_OK; 00233 #else 00234 return SD_ERR; 00235 #endif 00236 } 00237 00238 00239 00240 /****************************************************************************** 00241 * Function Name: int sddev_init(void); 00242 * Description : Initialize H/W to use SDHI 00243 * Arguments : none 00244 * Return Value : success : SD_OK 00245 * : fail : SD_ERR 00246 ******************************************************************************/ 00247 int sddev_init(int sd_port) 00248 { 00249 if ( sd_port >= SDHI_COUNT ) 00250 return SD_ERR; 00251 00252 00253 volatile uint8_t dummy_buf; 00254 00255 CPG.STBCR12 = 0xF0u; /* [1], [1], [1], [1], SDHI00, SDHI01, SDHI10, SDHI11 */ 00256 dummy_buf = CPG.STBCR12; /* (Dummy read) */ 00257 00258 00259 for( uint32_t no=0; no < SDHI_PINS_COMMON; no++ ) 00260 { 00261 if ( pinmap_peripheral(SDHIpin_Common[sd_port][no], PinMap_SDHI_PIN ) != sd_port) 00262 { 00263 return SD_ERR; 00264 } 00265 pinmap_pinout(SDHIpin_Common[sd_port][no], PinMap_SDHI_PIN); 00266 } 00267 00268 sddev_set_port(sd_port, SDHI_PORT_MODE); 00269 00270 #ifdef SDCFG_HWINT 00271 if ( sd_port == (uint32_t)SDHI_0 ) 00272 { 00273 InterruptHandlerRegister(SDHI0_0_IRQn, sddev_sd_int_handler_0); 00274 GIC_SetPriority(SDHI0_0_IRQn, INT_LEVEL_SDHI); 00275 GIC_EnableIRQ(SDHI0_0_IRQn); 00276 00277 InterruptHandlerRegister(SDHI0_3_IRQn, sddev_sd_int_handler_0); 00278 GIC_SetPriority(SDHI0_3_IRQn, INT_LEVEL_SDHI); 00279 GIC_EnableIRQ(SDHI0_3_IRQn); 00280 00281 InterruptHandlerRegister(SDHI0_1_IRQn, sddev_sdio_int_handler_0); 00282 GIC_SetPriority(SDHI0_1_IRQn, INT_LEVEL_SDHI); 00283 GIC_EnableIRQ(SDHI0_1_IRQn); 00284 } 00285 else if ( sd_port == (uint32_t)SDHI_1 ) 00286 { 00287 InterruptHandlerRegister(SDHI1_0_IRQn, sddev_sd_int_handler_1); 00288 GIC_SetPriority(SDHI1_0_IRQn, INT_LEVEL_SDHI); 00289 GIC_EnableIRQ(SDHI1_0_IRQn); 00290 00291 InterruptHandlerRegister(SDHI1_3_IRQn, sddev_sd_int_handler_1); 00292 GIC_SetPriority(SDHI1_3_IRQn, INT_LEVEL_SDHI); 00293 GIC_EnableIRQ(SDHI1_3_IRQn); 00294 00295 InterruptHandlerRegister(SDHI1_1_IRQn, sddev_sdio_int_handler_1); 00296 GIC_SetPriority(SDHI1_1_IRQn, INT_LEVEL_SDHI); 00297 GIC_EnableIRQ(SDHI1_1_IRQn); 00298 } 00299 #endif 00300 00301 /* ---- wait card detect ---- */ 00302 osDelay(100); /* wait 100ms */ 00303 00304 return SD_OK; 00305 } 00306 00307 00308 /****************************************************************************** 00309 * Function Name: int sddev_power_on(int sd_port); 00310 * Description : Power-on H/W to use SDHI 00311 * Arguments : none 00312 * Return Value : success : SD_OK 00313 * : fail : SD_ERR 00314 ******************************************************************************/ 00315 int sddev_power_on(int sd_port) 00316 { 00317 /* ---Power On SD ---- */ 00318 00319 /* ---- Wait for SD Wake up ---- */ 00320 osDelay(100); /* wait 100ms */ 00321 00322 return SD_OK; 00323 } 00324 00325 /****************************************************************************** 00326 * Function Name: int sddev_power_off(int sd_port); 00327 * Description : Power-off H/W to use SDHI 00328 * Arguments : none 00329 * Return Value : success : SD_OK 00330 * : fail : SD_ERR 00331 ******************************************************************************/ 00332 int sddev_power_off(int sd_port) 00333 { 00334 return SD_OK; 00335 } 00336 00337 /****************************************************************************** 00338 * Function Name: int sddev_read_data(int sd_port, unsigned char *buff,unsigned long reg_addr,long num); 00339 * Description : read from SDHI buffer FIFO 00340 * Arguments : unsigned char *buff : buffer addrees to store reading datas 00341 * : unsigned long reg_addr : SDIP FIFO address 00342 * : long num : counts to read(unit:byte) 00343 * Return Value : success : SD_OK 00344 * : fail : SD_ERR 00345 ******************************************************************************/ 00346 #ifdef __CC_ARM 00347 #pragma push 00348 #pragma Ospace 00349 #elif defined(__ICCARM__) 00350 #pragma optimize=size 00351 #elif (defined( __GNUC__ ) && !defined( __CC_ARM )) 00352 #pragma GCC push_options 00353 #pragma GCC optimize ("Os") 00354 #endif 00355 int sddev_read_data(int sd_port, unsigned char *buff,unsigned long reg_addr,long num) 00356 { 00357 long i; 00358 long cnt; 00359 unsigned long *reg; 00360 unsigned long *ptr_l; 00361 unsigned char *ptr_c; 00362 unsigned long tmp; 00363 00364 reg = (unsigned long *)(reg_addr); 00365 00366 cnt = (num / 4); 00367 if(((unsigned long)buff & 0x3) != 0) 00368 { 00369 ptr_c = (unsigned char *)buff; 00370 for(i = cnt; i > 0 ; i--) 00371 { 00372 tmp = *reg; 00373 *ptr_c++ = (unsigned char)(tmp); 00374 *ptr_c++ = (unsigned char)(tmp >> 8); 00375 *ptr_c++ = (unsigned char)(tmp >> 16); 00376 *ptr_c++ = (unsigned char)(tmp >> 24); 00377 } 00378 00379 cnt = (num % 4); 00380 if( cnt != 0 ) 00381 { 00382 tmp = *reg; 00383 for(i = cnt; i > 0 ; i--) 00384 { 00385 *ptr_c++ = (unsigned char)(tmp); 00386 tmp >>= 8; 00387 } 00388 } 00389 } 00390 else 00391 { 00392 ptr_l = (unsigned long *)buff; 00393 for(i = cnt; i > 0 ; i--) 00394 { 00395 *ptr_l++ = *reg; 00396 } 00397 00398 cnt = (num % 4); 00399 if( cnt != 0 ) 00400 { 00401 ptr_c = (unsigned char *)ptr_l; 00402 tmp = *reg; 00403 for(i = cnt; i > 0 ; i--) 00404 { 00405 *ptr_c++ = (unsigned char)(tmp); 00406 tmp >>= 8; 00407 } 00408 } 00409 } 00410 00411 return SD_OK; 00412 } 00413 #ifdef __CC_ARM 00414 #pragma pop 00415 #elif (defined( __GNUC__ ) && !defined( __CC_ARM )) 00416 #pragma GCC pop_options 00417 #endif 00418 00419 /****************************************************************************** 00420 * Function Name: int sddev_write_data(int sd_port, unsigned char *buff,unsigned long reg_addr,long num); 00421 * Description : write to SDHI buffer FIFO 00422 * Arguments : unsigned char *buff : buffer addrees to store writting datas 00423 * : unsigned long reg_addr : SDIP FIFO address 00424 * : long num : counts to write(unit:byte) 00425 * Return Value : success : SD_OK 00426 * : fail : SD_ERR 00427 ******************************************************************************/ 00428 int sddev_write_data(int sd_port, unsigned char *buff,unsigned long reg_addr,long num) 00429 { 00430 long i; 00431 unsigned long *reg = (unsigned long *)(reg_addr); 00432 unsigned long *ptr = (unsigned long *)buff; 00433 unsigned long tmp; 00434 00435 /* dont care non 4byte allignment data */ 00436 num += 3; 00437 num /= 4; 00438 if(((unsigned long)buff & 0x3) != 0) 00439 { 00440 for(i = num; i > 0 ; i--) 00441 { 00442 tmp = *buff++ ; 00443 tmp |= *buff++ << 8; 00444 tmp |= *buff++ << 16; 00445 tmp |= *buff++ << 24; 00446 *reg = tmp; 00447 } 00448 } 00449 else 00450 { 00451 for(i = num; i > 0 ; i--) 00452 { 00453 *reg = *ptr++; 00454 } 00455 } 00456 00457 return SD_OK; 00458 } 00459 00460 /****************************************************************************** 00461 * Function Name: unsigned int sddev_get_clockdiv(int sd_port, int clock); 00462 * Description : write to SDHI buffer FIFO 00463 * Arguments : int clock : request clock frequency 00464 * : SD_CLK_50MHz 00465 * : SD_CLK_25MHz 00466 * : SD_CLK_20MHz 00467 * : SD_CLK_10MHz 00468 * : SD_CLK_5MHz 00469 * : SD_CLK_1MHz 00470 * : SD_CLK_400kHz 00471 * Return Value : clock div value 00472 * : SD_DIV_2 : 1/2 clock 00473 * : SD_DIV_2 : 1/4 clock 00474 * : SD_DIV_2 : 1/8 clock 00475 * : SD_DIV_2 : 1/16 clock 00476 * : SD_DIV_2 : 1/128 clock 00477 * : SD_DIV_2 : 1/256 clock 00478 ******************************************************************************/ 00479 unsigned int sddev_get_clockdiv(int sd_port, int clock) 00480 { 00481 unsigned int div; 00482 00483 switch(clock) 00484 { 00485 case SD_CLK_50MHz: 00486 div = SD_DIV_2; /* 64MHz/2 = 32MHz */ 00487 break; 00488 case SD_CLK_25MHz: 00489 div = SD_DIV_4; /* 64MHz/4 = 16MHz */ 00490 break; 00491 case SD_CLK_20MHz: 00492 div = SD_DIV_4; /* 64MHz/4 = 16MHz */ 00493 break; 00494 case SD_CLK_10MHz: 00495 div = SD_DIV_8; /* 64MHz/8 = 8MHz */ 00496 break; 00497 case SD_CLK_5MHz: 00498 div = SD_DIV_16; /* 64MHz/16 = 4MHz */ 00499 break; 00500 case SD_CLK_1MHz: 00501 div = SD_DIV_128; /* 64MHz/128 = 512kHz */ 00502 break; 00503 case SD_CLK_400kHz: 00504 div = SD_DIV_256; /* 64MHz/256 = 256kHz */ 00505 break; 00506 default: 00507 div = SD_DIV_256; 00508 break; 00509 } 00510 00511 return div; 00512 } 00513 00514 /****************************************************************************** 00515 * Function Name: int sddev_set_port(int sd_port, int mode); 00516 * Description : setting ports to use MMCHI 00517 * Arguments : int mode : SD_PORT_PARALLEL : 4bit mode 00518 * : SD_PORT_SERIAL : 1bit mode 00519 * Return Value : success : SD_OK 00520 * : fail : SD_ERR 00521 ******************************************************************************/ 00522 int sddev_set_port(int sd_port, int mode) 00523 { 00524 if ( sd_port >= SDHI_COUNT) 00525 return SD_ERR; 00526 00527 if(mode == SD_PORT_SERIAL) 00528 { 00529 for( uint32_t no=0; no < SDHI_PINS_SERIAL; no++ ) 00530 { 00531 if ( pinmap_peripheral(SDHIpin_serial[sd_port][no], PinMap_SDHI_PIN ) != sd_port) 00532 { 00533 return SD_ERR; 00534 } 00535 pinmap_pinout(SDHIpin_serial[sd_port][no], PinMap_SDHI_PIN); 00536 } 00537 } 00538 else if( mode == SD_PORT_PARALLEL ) 00539 { 00540 for( uint32_t no=0; no < SDHI_PINS_PARALLEL; no++ ) 00541 { 00542 if ( pinmap_peripheral(SDHIpin_parallel[sd_port][no], PinMap_SDHI_PIN ) != sd_port) 00543 { 00544 return SD_ERR; 00545 } 00546 pinmap_pinout(SDHIpin_parallel[sd_port][no], PinMap_SDHI_PIN); 00547 } 00548 } 00549 else 00550 { 00551 return SD_ERR; 00552 } 00553 00554 return SD_OK; 00555 } 00556 00557 00558 /****************************************************************************** 00559 * Function Name: int sddev_int_wait(int sd_port, int time); 00560 * Description : Waitting for SDHI Interrupt 00561 * Arguments : int time : time out value to wait interrupt 00562 * Return Value : get interrupt : SD_OK 00563 * : time out : SD_ERR 00564 ******************************************************************************/ 00565 int sddev_int_wait(int sd_port, int time) 00566 { 00567 sddev_start_timer(time); 00568 while( sddev_check_timer() == SD_OK ) 00569 { 00570 /* interrupt generated? */ 00571 if(sd_check_int(sd_port) == SD_OK) 00572 { 00573 sddev_end_timer(); 00574 return SD_OK; 00575 } 00576 } 00577 00578 sddev_end_timer(); 00579 00580 return SD_ERR; 00581 } 00582 00583 /****************************************************************************** 00584 * Function Name: int sddev_init_dma(unsigned long buff,unsigned long reg,long cnt,int dir); 00585 * Description : Initialize DMAC to transfer data from SDHI FIFO 00586 * Arguments : unsigned long buff : buffer addrees to transfer datas 00587 * : unsigned long reg : SDIP FIFO address 00588 * : long cnt : counts to transfer(unit:byte) 00589 * : int dir : direction to transfer 00590 * : : 0 : FIFO -> buffer 00591 * : : 1 : buffer -> FIFO 00592 * Return Value : success : SD_OK 00593 * : fail : SD_ERR 00594 ******************************************************************************/ 00595 int sddev_init_dma(int sd_port, unsigned long buff,unsigned long reg,long cnt,int dir) 00596 { 00597 int ret; 00598 00599 if( sd_port == 0 ) 00600 { 00601 ret = sddev_init_dma_0(buff, reg, cnt, dir); 00602 } 00603 else if( sd_port == 1 ) 00604 { 00605 ret = sddev_init_dma_1(buff, reg, cnt, dir); 00606 } 00607 00608 return ret; 00609 } 00610 00611 /****************************************************************************** 00612 * Function Name: static int sddev_init_dma_0(unsigned long buff,unsigned long reg,long cnt,int dir); 00613 * Description : Initialize DMAC to transfer data from SDHI FIFO 00614 * Arguments : unsigned long buff : buffer addrees to transfer datas 00615 * : unsigned long reg : SDIP FIFO address 00616 * : long cnt : counts to transfer(unit:byte) 00617 * : int dir : direction to transfer 00618 * : : 0 : FIFO -> buffer 00619 * : : 1 : buffer -> FIFO 00620 * Return Value : success : SD_OK 00621 * : fail : SD_ERR 00622 ******************************************************************************/ 00623 static int sddev_init_dma_0(unsigned long buff,unsigned long reg,long cnt,int dir) 00624 { 00625 #ifdef SDCFG_TRNS_DMA 00626 dmac_transinfo_t trans_info; 00627 uint32_t request_factor; 00628 int32_t ret; 00629 00630 trans_info.count = (uint32_t)cnt; 00631 #ifdef SDCFG_TRANS_DMA_64 00632 if( (cnt % 64) != 0 ) 00633 { 00634 trans_info.src_size = DMAC_TRANS_SIZE_32; 00635 trans_info.dst_size = DMAC_TRANS_SIZE_32; 00636 if( reg & 0x0000003f ) 00637 { 00638 trans_info.src_size = DMAC_TRANS_SIZE_32; 00639 trans_info.dst_size = DMAC_TRANS_SIZE_32; 00640 } 00641 } 00642 else 00643 { 00644 trans_info.src_size = DMAC_TRANS_SIZE_512; 00645 trans_info.dst_size = DMAC_TRANS_SIZE_512; 00646 } 00647 #else 00648 trans_info.src_size = DMAC_TRANS_SIZE_32; 00649 trans_info.dst_size = DMAC_TRANS_SIZE_32; 00650 #endif 00651 00652 if( dir == 0 ) 00653 { 00654 request_factor = DMAC_REQ_SDHI_0_RX; 00655 trans_info.src_addr = (uint32_t)reg; 00656 trans_info.dst_addr = (uint32_t)buff; 00657 trans_info.saddr_dir = DMAC_TRANS_ADR_NO_INC; 00658 trans_info.daddr_dir = DMAC_TRANS_ADR_INC; 00659 } 00660 else if( dir == 1 ) 00661 { 00662 request_factor = DMAC_REQ_SDHI_0_TX; 00663 trans_info.src_addr = (uint32_t)buff; 00664 trans_info.dst_addr = (uint32_t)reg; 00665 trans_info.saddr_dir = DMAC_TRANS_ADR_INC; 00666 trans_info.daddr_dir = DMAC_TRANS_ADR_NO_INC; 00667 } 00668 00669 sd_DMAC1_PeriReqInit( (const dmac_transinfo_t *)&trans_info, 00670 DMAC_MODE_REGISTER, 00671 DMAC_SAMPLE_SINGLE, 00672 request_factor, 00673 0 ); /* Dont care DMAC_REQ_REQD is setting in usb0_host_DMAC1_PeriReqInit() */ 00674 00675 ret = sd_DMAC1_Open(DMAC_REQ_MODE_PERI); 00676 if( ret != 0 ) 00677 { 00678 printf("DMAC1 Open error!!\n"); 00679 return SD_ERR; 00680 } 00681 #endif 00682 00683 return SD_OK; 00684 } 00685 00686 /****************************************************************************** 00687 * Function Name: static int sddev_init_dma_1(unsigned long buff,unsigned long reg,long cnt,int dir); 00688 * Description : Initialize DMAC to transfer data from SDHI FIFO 00689 * Arguments : unsigned long buff : buffer address to transfer datas 00690 * : unsigned long reg : SDIP FIFO address 00691 * : long cnt : counts to transfer(unit:byte) 00692 * : int dir : direction to transfer 00693 * : : 0 : FIFO -> buffer 00694 * : : 1 : buffer -> FIFO 00695 * Return Value : success : SD_OK 00696 * : fail : SD_ERR 00697 ******************************************************************************/ 00698 static int sddev_init_dma_1(unsigned long buff,unsigned long reg,long cnt,int dir) 00699 { 00700 #ifdef SDCFG_TRNS_DMA 00701 dmac_transinfo_t trans_info; 00702 uint32_t request_factor; 00703 int32_t ret; 00704 00705 trans_info.count = (uint32_t)cnt; 00706 #ifdef SDCFG_TRANS_DMA_64 00707 if( (cnt % 64) != 0 ) 00708 { 00709 trans_info.src_size = DMAC_TRANS_SIZE_32; 00710 trans_info.dst_size = DMAC_TRANS_SIZE_32; 00711 if( reg & 0x0000003f ) 00712 { 00713 trans_info.src_size = DMAC_TRANS_SIZE_32; 00714 trans_info.dst_size = DMAC_TRANS_SIZE_32; 00715 } 00716 } 00717 else 00718 { 00719 trans_info.src_size = DMAC_TRANS_SIZE_512; 00720 trans_info.dst_size = DMAC_TRANS_SIZE_512; 00721 } 00722 #else 00723 trans_info.src_size = DMAC_TRANS_SIZE_32; 00724 trans_info.dst_size = DMAC_TRANS_SIZE_32; 00725 #endif 00726 00727 if( dir == 0 ) 00728 { 00729 request_factor = DMAC_REQ_SDHI_1_RX; 00730 trans_info.src_addr = (uint32_t)reg; 00731 trans_info.dst_addr = (uint32_t)buff; 00732 trans_info.saddr_dir = DMAC_TRANS_ADR_NO_INC; 00733 trans_info.daddr_dir = DMAC_TRANS_ADR_INC; 00734 } 00735 else if( dir == 1 ) 00736 { 00737 request_factor = DMAC_REQ_SDHI_1_TX; 00738 trans_info.src_addr = (uint32_t)buff; 00739 trans_info.dst_addr = (uint32_t)reg; 00740 trans_info.saddr_dir = DMAC_TRANS_ADR_INC; 00741 trans_info.daddr_dir = DMAC_TRANS_ADR_NO_INC; 00742 } 00743 00744 sd_DMAC2_PeriReqInit( (const dmac_transinfo_t *)&trans_info, 00745 DMAC_MODE_REGISTER, 00746 DMAC_SAMPLE_SINGLE, 00747 request_factor, 00748 0 ); /* Dont care DMAC_REQ_REQD is setting in usb0_host_DMAC1_PeriReqInit() */ 00749 00750 ret = sd_DMAC2_Open(DMAC_REQ_MODE_PERI); 00751 if( ret != 0 ) 00752 { 00753 printf("DMAC1 Open error!!\n"); 00754 return SD_ERR; 00755 } 00756 #endif 00757 00758 return SD_OK; 00759 } 00760 00761 /****************************************************************************** 00762 * Function Name: int sddev_wait_dma_end(int sd_port, long cnt); 00763 * Description : Wait to complete DMAC transfer 00764 * Arguments : long cnt : counts to transfer(unit:byte) 00765 * Return Value : success : SD_OK 00766 * : fail : SD_ERR 00767 ******************************************************************************/ 00768 int sddev_wait_dma_end(int sd_port, long cnt) 00769 { 00770 int ret; 00771 00772 if( sd_port == 0 ) 00773 { 00774 ret = sddev_wait_dma_end_0(cnt); 00775 } 00776 else if( sd_port == 1 ) 00777 { 00778 ret = sddev_wait_dma_end_1(cnt); 00779 } 00780 00781 return ret; 00782 } 00783 00784 /****************************************************************************** 00785 * Function Name: static int sddev_wait_dma_end_0(long cnt); 00786 * Description : Wait to complete DMAC transfer 00787 * Arguments : long cnt : counts to transfer(unit:byte) 00788 * Return Value : success : SD_OK 00789 * : fail : SD_ERR 00790 ******************************************************************************/ 00791 static int sddev_wait_dma_end_0(long cnt) 00792 { 00793 #ifdef SDCFG_TRNS_DMA 00794 int loop; 00795 int time; 00796 00797 time = (cnt / 512); 00798 time = ((time * 1000) / 1024); 00799 if(time < 1000) 00800 { 00801 time = 1000; 00802 } 00803 00804 if(time > (0x0000ffff / MTU_TIMER_CNT)) 00805 { 00806 /* @1000ms */ 00807 loop = (time / 1000); 00808 if( (time % 1000) != 0 ) 00809 { 00810 loop++; 00811 } 00812 time = 1000; 00813 } 00814 else 00815 { 00816 loop = 1; 00817 } 00818 00819 do{ 00820 sddev_start_timer(time); 00821 00822 while(1) 00823 { 00824 /* get end flag? */ 00825 if( sd_DMAC1_Get_Endflag() == 1 ) 00826 { 00827 sddev_end_timer(); 00828 return SD_OK; 00829 } 00830 /* detect timeout? */ 00831 if(sddev_check_timer() == SD_ERR) 00832 { 00833 break; 00834 } 00835 } 00836 00837 loop--; 00838 if( loop <= 0 ) 00839 { 00840 break; 00841 } 00842 00843 } while(1); 00844 00845 sddev_end_timer(); 00846 00847 return SD_ERR; 00848 #else 00849 return SD_OK; 00850 00851 #endif 00852 } 00853 00854 /****************************************************************************** 00855 * Function Name: static int sddev_wait_dma_end_1(long cnt); 00856 * Description : Wait to complete DMAC transfer 00857 * Arguments : long cnt : counts to transfer(unit:byte) 00858 * Return Value : success : SD_OK 00859 * : fail : SD_ERR 00860 ******************************************************************************/ 00861 static int sddev_wait_dma_end_1(long cnt) 00862 { 00863 #ifdef SDCFG_TRNS_DMA 00864 int loop; 00865 int time; 00866 00867 time = (cnt / 512); 00868 time = ((time * 1000) / 1024); 00869 if(time < 1000) 00870 { 00871 time = 1000; 00872 } 00873 00874 if(time > (0x0000ffff / MTU_TIMER_CNT)) 00875 { 00876 /* @1000ms */ 00877 loop = (time / 1000); 00878 if( (time % 1000) != 0 ) 00879 { 00880 loop++; 00881 } 00882 time = 1000; 00883 } 00884 else 00885 { 00886 loop = 1; 00887 } 00888 00889 do{ 00890 sddev_start_timer(time); 00891 00892 while(1) 00893 { 00894 /* get end flag? */ 00895 if( sd_DMAC2_Get_Endflag() == 1 ) 00896 { 00897 sddev_end_timer(); 00898 return SD_OK; 00899 } 00900 /* detect timeout? */ 00901 if(sddev_check_timer() == SD_ERR) 00902 { 00903 break; 00904 } 00905 } 00906 00907 loop--; 00908 if( loop <= 0 ) 00909 { 00910 break; 00911 } 00912 00913 } while(1); 00914 00915 sddev_end_timer(); 00916 00917 return SD_ERR; 00918 #else 00919 return SD_OK; 00920 00921 #endif 00922 } 00923 00924 /****************************************************************************** 00925 * Function Name: int sddev_disable_dma(int sd_port); 00926 * Description : Disable DMAC transfer 00927 * Arguments : none 00928 * Return Value : success : SD_OK 00929 * : fail : SD_ERR 00930 ******************************************************************************/ 00931 int sddev_disable_dma(int sd_port) 00932 { 00933 int ret; 00934 00935 if( sd_port == 0 ) 00936 { 00937 ret = sddev_disable_dma_0(); 00938 } 00939 else 00940 { 00941 ret = sddev_disable_dma_1(); 00942 } 00943 return ret; 00944 } 00945 00946 /****************************************************************************** 00947 * Function Name: static int sddev_disable_dma_0(void); 00948 * Description : Disable DMAC transfer 00949 * Arguments : none 00950 * Return Value : success : SD_OK 00951 * : fail : SD_ERR 00952 ******************************************************************************/ 00953 static int sddev_disable_dma_0(void) 00954 { 00955 #ifdef SDCFG_TRNS_DMA 00956 uint32_t remain; 00957 00958 sd_DMAC1_Close(&remain); 00959 #endif 00960 return SD_OK; 00961 } 00962 00963 /****************************************************************************** 00964 * Function Name: staticint sddev_disable_dma_1(void); 00965 * Description : Disable DMAC transfer 00966 * Arguments : none 00967 * Return Value : success : SD_OK 00968 * : fail : SD_ERR 00969 ******************************************************************************/ 00970 static int sddev_disable_dma_1(void) 00971 { 00972 #ifdef SDCFG_TRNS_DMA 00973 uint32_t remain; 00974 00975 sd_DMAC2_Close(&remain); 00976 #endif 00977 return SD_OK; 00978 } 00979 00980 /****************************************************************************** 00981 * Function Name: int sddev_loc_cpu(int sd_port); 00982 * Description : lock cpu to disable interrupt 00983 * Arguments : none 00984 * Return Value : success : SD_OK 00985 * : fail : SD_ERR 00986 ******************************************************************************/ 00987 int sddev_loc_cpu(int sd_port) 00988 { 00989 #if 0 00990 R_INTC_GetMaskLevel(&g_sdhi_priority_backup); 00991 R_INTC_SetMaskLevel(0); 00992 core_util_critical_section_enter(); 00993 #endif 00994 00995 return SD_OK; 00996 } 00997 00998 /****************************************************************************** 00999 * Function Name: int sddev_unl_cpu(int sd_port); 01000 * Description : unlock cpu to enable interrupt 01001 * Arguments : none 01002 * Return Value : success : SD_OK 01003 * : fail : SD_ERR 01004 ******************************************************************************/ 01005 int sddev_unl_cpu(int sd_port) 01006 { 01007 #if 0 01008 R_INTC_SetMaskLevel(g_sdhi_priority_backup); 01009 core_util_critical_section_exit(); 01010 #endif 01011 return SD_OK; 01012 } 01013 01014 /****************************************************************************** 01015 * Function Name: int sddev_finalize(int sd_port); 01016 * Description : finalize SDHI 01017 * Arguments : none 01018 * Return Value : none 01019 ******************************************************************************/ 01020 int sddev_finalize(int sd_port) 01021 { 01022 return SD_OK; 01023 } 01024 01025 /****************************************************************************** 01026 * Function Name: static void sddev_sd_int_handler_0(uint32_t int_sense); 01027 * Description : Setting Interrupt function for SDHI(INTC_ID_SDHI0_0,INTC_ID_SDHI0_3) 01028 * Arguments : Interrupt mode 01029 * Return Value : none 01030 ******************************************************************************/ 01031 static void sddev_sd_int_handler_0(uint32_t int_sense) 01032 { 01033 sd_int_handler(0); 01034 } 01035 01036 /****************************************************************************** 01037 * Function Name: static void sddev_sd_int_handler_1(uint32_t int_sense); 01038 * Description : Setting Interrupt function for SDHI(INTC_ID_SDHI0_0,INTC_ID_SDHI0_3) 01039 * Arguments : Interrupt mode 01040 * Return Value : none 01041 ******************************************************************************/ 01042 static void sddev_sd_int_handler_1(uint32_t int_sense) 01043 { 01044 sd_int_handler(1); 01045 } 01046 01047 /****************************************************************************** 01048 * Function Name: static void sddev_sdio_int_handler_0(uint32_t int_sense); 01049 * Description : Setting Interrupt function for SDHI(INTC_ID_SDHI0_1) 01050 * Arguments : Interrupt mode 01051 * Return Value : none 01052 ******************************************************************************/ 01053 static void sddev_sdio_int_handler_0(uint32_t int_sense) 01054 { 01055 sdio_int_handler(0); 01056 } 01057 01058 /****************************************************************************** 01059 * Function Name: static void sddev_sdio_int_handler_1(uint32_t int_sense); 01060 * Description : Setting Interrupt function for SDHI(INTC_ID_SDHI1_1) 01061 * Arguments : Interrupt mode 01062 * Return Value : none 01063 ******************************************************************************/ 01064 static void sddev_sdio_int_handler_1(uint32_t int_sense) 01065 { 01066 sdio_int_handler(1); 01067 } 01068 01069 /****************************************************************************** 01070 * Function Name: static void sddev_start_timer(int msec); 01071 * Description : start timer 01072 * Arguments : 01073 * Return Value : none 01074 ******************************************************************************/ 01075 static void sddev_start_timer(int msec) 01076 { 01077 _ticker = get_us_ticker_data(); 01078 _ulStart = ticker_read(_ticker); 01079 _ulDelta = msec*1000ul; 01080 } 01081 01082 /****************************************************************************** 01083 * Function Name: static void sddev_end_timer(void); 01084 * Description : end timer 01085 * Arguments : 01086 * Return Value : none 01087 ******************************************************************************/ 01088 static void sddev_end_timer(void) 01089 { 01090 _ulStart = 0ul; 01091 _ulDelta = 0ul; 01092 } 01093 01094 /****************************************************************************** 01095 * Function Name: static int sddev_check_timer(void); 01096 * Description : check 01097 * Arguments : 01098 * Return Value : t 01099 ******************************************************************************/ 01100 static int sddev_check_timer(void) 01101 { 01102 if ( _ulStart && _ulDelta ) 01103 { 01104 return ((ticker_read(_ticker)-_ulStart) < _ulDelta) ? SD_OK : SD_ERR; 01105 } 01106 else 01107 { 01108 return SD_ERR; 01109 } 01110 } 01111 01112 /* End of File */ 01113
Generated on Sun Jul 17 2022 03:41:56 by
1.7.2