git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/T-HEAD_CB2201_CDK/csi/csi_driver/csky/phobos/devices.c

   1 /*
   2  * Copyright (C) 2017 C-SKY Microsystems Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /******************************************************************************
  18  * @file     devices.c
  19  * @brief    source file for the devices
  20  * @version  V1.0
  21  * @date     02. June 2017
  22  ******************************************************************************/
  23 #include "soc.h"
  24 #include "config.h"
  25 #include <drv_usart.h>
  26 #include <drv_trng.h>
  27 #include <drv_crc.h>
  28 #include <drv_aes.h>
  29 #include <drv_rsa.h>
  30 #include <drv_eflash.h>
  31 #include <drv_timer.h>
  32 #include <drv_gpio.h>
  33 #include <drv_iic.h>
  34 #include <drv_rtc.h>
  35 #include <drv_spi.h>
  36 #include <drv_wdt.h>
  37 #include <drv_sha.h>
  38 #include <drv_pwm.h>
  39 #include <drv_dmac.h>
  40 #include <stdio.h>
  41
  42
  43 #include "pin_name.h"
  44 #include "pinmux.h"
  45
  46 //typedef int32_t pin_t;
  47
  48
  49 #if CONFIG_IIC
  50
  51
  52 struct {
  53     uint32_t base;
  54     uint32_t irq;
  55 }
  56 const sg_iic_config[CONFIG_IIC_NUM] = {
  57     {CSKY_I2C0_BASE, I2C0_IRQn},
  58     {CSKY_I2C1_BASE, I2C1_IRQn}
  59 };
  60
  61
  62 typedef struct {
  63     pin_t    scl;
  64     pin_t    sda;
  65     uint16_t cfg_idx;    //idx of sg_iic_config[]
  66     uint16_t function;
  67     //uint32_t scl_reg;
  68     //uint32_t scl_cfg;
  69     //uint32_t sda_reg;
  70     //uint32_t sda_cfg;
  71 } iic_pin_map_t;
  72 const static iic_pin_map_t s_iic_pin_map[] = {
  73     {
  74         PA4_SCL0_PWM4_SPI0RX_XX,
  75         PA5_SDA0_PWM5_SPI0CS_XX,
  76         0,
  77         0
  78     },
  79     {
  80         PA6_SPI0CLK_PWMTRIG0_SCL0_XX,
  81         PA7_SPI0TX_PWMTRIG1_SDA0_XX,
  82         0,
  83         2
  84     },
  85     {
  86         PA31_I2SSDA__SCL0_PWM4_XX,
  87         PB0_ADC0_SDA0_PWM5_XX,
  88         0,
  89         1
  90     },
  91     {
  92         PA8_SPI0RX_TRIGFAULT_SCL1_XX,
  93         PA9_SPI0CS_PWM0_SDA1_XX,
  94         1,
  95         2
  96     },
  97     {
  98         PA14_SCL1_PWM5_SPI1RX_XX,
  99         PA15_SDA1_PWMTRIG0_SPI1CS0_XX,
 100         1,
 101         0
 102     },
 103     {
 104         PB1_ADC1_SCL1_USISCLK_XX,
 105         PB2_ADC2_SDA1_USISD0_XX,
 106         1,
 107         1
 108     }
 109 };
 110
 111
 112 /**
 113   \param[in]   instance idx, must not exceed return value of target_get_iic_count()
 114   \brief       get iic instance.
 115   \return      pointer to iic instance
 116 */
 117 int32_t target_iic_init(pin_t scl, pin_t sda, uint32_t *base, uint32_t *irq)
 118 {
 119     uint32_t idx;
 120
 121     for (idx = 0; idx < sizeof(s_iic_pin_map) / sizeof(iic_pin_map_t); idx++) {
 122         if (s_iic_pin_map[idx].scl == scl && s_iic_pin_map[idx].sda == sda) {
 123             *base = sg_iic_config[s_iic_pin_map[idx].cfg_idx].base;
 124             *irq = sg_iic_config[s_iic_pin_map[idx].cfg_idx].irq;
 125             /*pinmux*/
 126             pin_mux(s_iic_pin_map[idx].scl, s_iic_pin_map[idx].function);
 127             pin_mux(s_iic_pin_map[idx].sda, s_iic_pin_map[idx].function);
 128             return s_iic_pin_map[idx].cfg_idx;
 129         }
 130     }
 131
 132     return -1;
 133 }
 134
 135
 136 #endif
 137
 138 #if CONFIG_USART
 139 struct {
 140     uint32_t base;
 141     uint32_t irq;
 142 }
 143 const sg_usart_config[CONFIG_USART_NUM] = {
 144     {CSKY_UART0_BASE, UART0_IRQn},
 145     {CSKY_UART1_BASE, UART1_IRQn},
 146     {CSKY_UART2_BASE, UART2_IRQn},
 147     {CSKY_UART3_BASE, UART3_IRQn}
 148 };
 149 typedef struct {
 150     pin_t    tx;
 151     pin_t    rx;
 152     pin_t    cts;
 153     pin_t    rts;
 154     uint16_t cfg_idx;    //idx of sg_usart_config[]
 155     uint16_t function;
 156 } usart_pin_map_t;
 157 const static usart_pin_map_t s_usart_pin_map[] = {
 158     {
 159         PA0_TXD0_PWM0_XX_SIROUT0,
 160         PA1_RXD0_PWM1_XX_SIRIN0,
 161         -1,
 162         -1,
 163         0,
 164         0
 165     },
 166     {
 167         PA10_TXD1_PWM1_XX_SIROUT1,
 168         PA11_RXD1_PWM2_XX_SIRIN1,
 169         -1,
 170         -1,
 171         1,
 172         0
 173     },
 174     {
 175         PA23_TXD2_PWM5_XX_SIROUT2,
 176         PA22_RXD2_PWM4_XX_SIRIN2,
 177         PA24_CTS2_PWMTRIG0_SPI1CS1_XX,
 178         PA25_XX_PWMTRIG1_SPI1CS2_XX,
 179         2,
 180         0
 181     },
 182     {
 183         PA26_TXD3_PWMFAULT_XX_SIROUT3,
 184         PA27_RXD3_PWM0_XX_SIRIN3,
 185         -1,
 186         -1,
 187         3,
 188         0
 189     }
 190 };
 191
 192 /**
 193   \param[in]   instance idx, must not exceed return value of target_get_usart_count()
 194   \brief       get usart instance.
 195   \return      pointer to usart instance
 196 */
 197 int32_t target_usart_init(pin_t tx, pin_t rx, uint32_t *base, uint32_t *irq)
 198 {
 199     uint32_t idx;
 200
 201     for (idx = 0; idx < sizeof(s_usart_pin_map) / sizeof(usart_pin_map_t); idx++) {
 202         if (s_usart_pin_map[idx].tx == tx && s_usart_pin_map[idx].rx == rx) {
 203             *base = sg_usart_config[s_usart_pin_map[idx].cfg_idx].base;
 204             *irq = sg_usart_config[s_usart_pin_map[idx].cfg_idx].irq;
 205             /*pinmux*/
 206             pin_mux(s_usart_pin_map[idx].tx, s_usart_pin_map[idx].function);
 207             pin_mux(s_usart_pin_map[idx].rx, s_usart_pin_map[idx].function);
 208             return s_usart_pin_map[idx].cfg_idx;
 209         }
 210     }
 211
 212     return -1;
 213
 214 }
 215 /**
 216   \brief       control usart flow.
 217   \param[in]   tx_flow  The TX flow pin name
 218   \param[in]   rx_flow  The RX flow pin name
 219   \param[in]   flag 0-disable, 1-enable.
 220   \return      0 if setting ready ,negative for error code
 221 */
 222 int32_t target_usart_flowctrl_init(pin_t tx_flow, pin_t rx_flow, uint32_t flag)
 223 {
 224     uint32_t idx;
 225
 226     for (idx = 0; idx < sizeof(s_usart_pin_map) / sizeof(usart_pin_map_t); idx++) {
 227         if ((s_usart_pin_map[idx].cts == tx_flow) &&(s_usart_pin_map[idx].rts == rx_flow))
 228             break;
 229     }
 230
 231     if (idx >= sizeof(s_usart_pin_map) / sizeof(usart_pin_map_t)) {
 232         return -1;
 233     }
 234
 235     if ((s_usart_pin_map[idx].cts == tx_flow) && flag) {
 236         pin_mux(s_usart_pin_map[idx].cts, s_usart_pin_map[idx].function);
 237     } else if ((s_usart_pin_map[idx].cts == tx_flow) && (flag == 0)) {
 238         pin_mux(s_usart_pin_map[idx].cts, 0xff);
 239     } else {
 240         return -1;
 241     }
 242
 243     if ((s_usart_pin_map[idx].rts == rx_flow) && flag) {
 244         pin_mux(s_usart_pin_map[idx].rts, s_usart_pin_map[idx].function);
 245     } else if ((s_usart_pin_map[idx].rts == rx_flow) && (flag == 0)) {
 246         pin_mux(s_usart_pin_map[idx].rts, 0xff);
 247     } else {
 248         return -1;
 249     }
 250
 251     return 0;
 252 }
 253
 254 #endif
 255
 256 #if CONFIG_TRNG
 257 struct {
 258     uint32_t base;
 259 }
 260 const sg_trng_config[CONFIG_TRNG_NUM] = {
 261     {CSKY_TRNG_BASE}
 262 };
 263
 264 /**
 265   \brief       get trng instance count.
 266   \return      trng instance count
 267 */
 268 int32_t target_get_trng_count(void)
 269 {
 270     return CONFIG_TRNG_NUM;
 271 }
 272
 273 /**
 274   \param[in]   instance idx, must not exceed return value of target_get_trng_count()
 275   \brief       get trng instance.
 276   \return      pointer to trng instance
 277 */
 278 int32_t target_get_trng(int32_t idx, uint32_t *base)
 279 {
 280     if (idx >= target_get_trng_count()) {
 281         return NULL;
 282     }
 283
 284     *base = sg_trng_config[idx].base;
 285     return idx;
 286 }
 287
 288 #endif
 289
 290 #if CONFIG_CRC
 291 struct {
 292     uint32_t base;
 293 }
 294 const sg_crc_config[CONFIG_CRC_NUM] = {
 295     {CSKY_CRC_BASE}
 296 };
 297
 298 /**
 299   \brief       get crc instance count.
 300   \return      crc instance count
 301 */
 302 int32_t target_get_crc_count(void)
 303 {
 304     return CONFIG_CRC_NUM;
 305 }
 306
 307 /**
 308   \param[in]   instance idx, must not exceed return value of target_get_crc_count()
 309   \brief       get crc instance.
 310   \return      pointer to crc instance
 311 */
 312 int32_t target_get_crc(int32_t idx, uint32_t *base)
 313 {
 314     if (idx >= target_get_crc_count()) {
 315         return NULL;
 316     }
 317
 318     *base = sg_crc_config[idx].base;
 319     return idx;
 320 }
 321
 322 #endif
 323
 324
 325 #if CONFIG_EFLASH
 326 struct {
 327     uint32_t base;
 328     eflash_info info;
 329 }
 330 const sg_eflash_config[CONFIG_EFLASH_NUM] = {
 331     {CSKY_EFLASH_CONTROL_BASE, {0x10000000, 0x1003f800, 0x1fc}}
 332 };
 333
 334 /**
 335   \brief       get eflash instance count.
 336   \return      eflash instance count
 337 */
 338 int32_t target_get_eflash_count(void)
 339 {
 340     return CONFIG_EFLASH_NUM;
 341 }
 342
 343 /**
 344   \param[in]   instance idx, must not exceed return value of target_get_eflash_count()
 345   \brief       get eflash instance.
 346   \return      pointer to eflash instance
 347 */
 348 int32_t target_get_eflash(int32_t idx, uint32_t *base, eflash_info *info)
 349 {
 350     if (idx >= target_get_eflash_count()) {
 351         return NULL;
 352     }
 353
 354     *base = sg_eflash_config[idx].base;
 355     info->start = sg_eflash_config[idx].info.start;
 356     info->end = sg_eflash_config[idx].info.end;
 357     info->sector_count = sg_eflash_config[idx].info.sector_count;
 358     return idx;
 359 }
 360
 361 #endif
 362
 363 #if CONFIG_TIMER
 364 struct {
 365     uint32_t base;
 366     uint32_t irq;
 367 }
 368 const sg_timer_config[CONFIG_TIMER_NUM] = {
 369     {CSKY_TIMERA0_BASE, TIMA0_IRQn},
 370     {CSKY_TIMERA1_BASE, TIMA1_IRQn},
 371     {CSKY_TIMERB0_BASE, TIMB0_IRQn},
 372     {CSKY_TIMERB1_BASE, TIMB1_IRQn}
 373 };
 374
 375 int32_t target_get_timer_count(void)
 376 {
 377     return CONFIG_TIMER_NUM;
 378 }
 379
 380 int32_t target_get_timer(int32_t idx, uint32_t *base, uint32_t *irq)
 381 {
 382     if (idx >= target_get_timer_count()) {
 383         return NULL;
 384     }
 385
 386     *base = sg_timer_config[idx].base;
 387     *irq = sg_timer_config[idx].irq;
 388     return idx;
 389 }
 390
 391 #endif
 392
 393 #if CONFIG_GPIO
 394 struct {
 395     uint32_t base;
 396     uint32_t irq;
 397     uint32_t pin_num;
 398     port_name_t port;
 399 }
 400 const sg_gpio_config[CONFIG_GPIO_NUM] = {
 401     {CSKY_GPIOA_BASE, GPIOA_IRQn, 32, PORTA},
 402     {CSKY_GPIOB_BASE, GPIOB_IRQn, 11, PORTB}
 403 };
 404
 405 typedef struct {
 406     pin_t    gpio_pin;
 407     uint32_t cfg_idx;    //idx of sg_gpio_config[]
 408 } gpio_pin_map_t;
 409 const static gpio_pin_map_t s_gpio_pin_map[] = {
 410     {PA0_TXD0_PWM0_XX_SIROUT0, 0},
 411     {PA1_RXD0_PWM1_XX_SIRIN0, 0},
 412     {PA2_CTS0_PWM2_SPI0CLK_XX, 0},
 413     {PA3_RTS0_PWM3_SPI0TX_XX, 0},
 414     {PA4_SCL0_PWM4_SPI0RX_XX, 0},
 415     {PA5_SDA0_PWM5_SPI0CS_XX, 0},
 416     {PA6_SPI0CLK_PWMTRIG0_SCL0_XX, 0},
 417     {PA7_SPI0TX_PWMTRIG1_SDA0_XX, 0},
 418     {PA8_SPI0RX_TRIGFAULT_SCL1_XX, 0},
 419     {PA9_SPI0CS_PWM0_SDA1_XX, 0},
 420     {PA10_TXD1_PWM1_XX_SIROUT1, 0},
 421     {PA11_RXD1_PWM2_XX_SIRIN1, 0},
 422     {PA12_CTS1_PWM3_SPI1CLK_XX, 0},
 423     {PA13_RTS1_PWM4_SPI1TX_XX, 0},
 424     {PA14_SCL1_PWM5_SPI1RX_XX, 0},
 425     {PA15_SDA1_PWMTRIG0_SPI1CS0_XX, 0},
 426     {PA16_SPI1CLK_PWMTRIG1_XX_XX, 0},
 427     {PA17_SPI1TX_PWMFAULT_XX_XX, 0},
 428     {PA18_SPI1RX_PWM0_XX_XX, 0},
 429     {PA19_SPI1CS0_PWM1_XX_XX, 0},
 430     {PA20_SPI1CS1_PWM2_XX_XX, 0},
 431     {PA21_SPI1CS2_PWM3_XX_XX, 0},
 432     {PA22_RXD2_PWM4_XX_SIRIN2, 0},
 433     {PA23_TXD2_PWM5_XX_SIROUT2, 0},
 434     {PA24_CTS2_PWMTRIG0_SPI1CS1_XX, 0},
 435     {PA25_XX_PWMTRIG1_SPI1CS2_XX, 0},
 436     {PA26_TXD3_PWMFAULT_XX_SIROUT3, 0},
 437     {PA27_RXD3_PWM0_XX_SIRIN3, 0},
 438     {PA28_I2SMCLK_PWM1_XX_XX, 0},
 439     {PA29_I2SSCLK_PWM2_XX_XX, 0},
 440     {PA30_I2SWSCLK_PWM3_XX_XX, 0},
 441     {PA31_I2SSDA__SCL0_PWM4_XX, 0},
 442     {PB0_ADC0_SDA0_PWM5_XX, 1},
 443     {PB1_ADC1_SCL1_USISCLK_XX, 1},
 444     {PB2_ADC2_SDA1_USISD0_XX, 1},
 445     {PB3_ADC3_SPI1CLK_USISD1_XX, 1},
 446     {PB4_ADC4_SPI1TX_USINSS_XX, 1},
 447     {PB5_ADC5_SPI1RX_USISCLK_XX, 1},
 448     {PB6_ADC6_SPI1CS0_USISD0_XX, 1},
 449     {PB7_ADC7_SPI1CS1_USISD1_XX, 1},
 450     {PB8_PWMTRIG0_SPI1CS2_USINSS_XX, 1},
 451     {PB9_PWMTRIG1_CTS3_XX_XX, 1},
 452     {PB10_PWMFAULT_RTS3_XX_XX, 1}
 453 };
 454
 455 int32_t target_gpio_port_init(port_name_t port, uint32_t *base, uint32_t *irq, uint32_t *pin_num)
 456 {
 457     int i;
 458
 459     for (i = 0; i < CONFIG_GPIO_NUM; i++) {
 460         if (sg_gpio_config[i].port == port) {
 461             *base = sg_gpio_config[i].base;
 462             *irq = sg_gpio_config[i].irq;
 463             *pin_num = sg_gpio_config[i].pin_num;
 464             return i;
 465         }
 466     }
 467
 468     return -1;
 469 }
 470
 471 /**
 472   \param[in]   instance idx, must not exceed return value of target_get_gpio_count()
 473   \brief       get gpio instance.
 474   \return      pointer to gpio instance
 475 */
 476 int32_t target_gpio_pin_init(pin_t gpio_pin, uint32_t *port_idx)
 477 {
 478     uint32_t idx;
 479
 480     for (idx = 0; idx < sizeof(s_gpio_pin_map) / sizeof(gpio_pin_map_t); idx++) {
 481         if (s_gpio_pin_map[idx].gpio_pin == gpio_pin) {
 482             *port_idx = s_gpio_pin_map[idx].cfg_idx;
 483             /*pinmux*/
 484             pin_mux(s_gpio_pin_map[idx].gpio_pin, 0xff);
 485             if (idx >= 32) {
 486                 return idx-32;
 487             }
 488             return idx;
 489         }
 490     }
 491
 492     return -1;
 493 }
 494
 495 #endif
 496
 497 #if CONFIG_AES
 498 struct {
 499     uint32_t base;
 500     uint32_t irq;
 501 }
 502 const sg_aes_config[CONFIG_AES_NUM] = {
 503     {CSKY_AES_BASE, AES_IRQn}
 504 };
 505
 506 /**
 507   \brief       get aes instance count.
 508   \return      aes instance count
 509 */
 510 int32_t target_get_aes_count(void)
 511 {
 512     return CONFIG_AES_NUM;
 513 }
 514
 515 /**
 516   \param[in]   instance idx, must not exceed return value of target_get_aes_count()
 517   \brief       get aes instance.
 518   \return      pointer to aes instance
 519 */
 520 int32_t target_get_aes(int32_t idx, uint32_t *base, uint32_t *irq)
 521 {
 522     if (idx >= target_get_aes_count()) {
 523         return NULL;
 524     }
 525
 526     *base = sg_aes_config[idx].base;
 527     *irq = sg_aes_config[idx].irq;
 528     return idx;
 529 }
 530
 531 #endif
 532
 533
 534 #if CONFIG_RSA
 535 struct {
 536     uint32_t base;
 537     uint32_t irq;
 538 }
 539 const sg_rsa_config[CONFIG_RSA_NUM] = {
 540     {CSKY_RSA_BASE, RSA_IRQn}
 541 };
 542
 543 /**
 544   \brief       get rsa instance count.
 545   \return      rsa instance count
 546 */
 547 int32_t target_get_rsa_count(void)
 548 {
 549     return CONFIG_RSA_NUM;
 550 }
 551
 552 /**
 553   \param[in]   instance idx, must not exceed return value of target_get_rsa_count()
 554   \brief       get rsa instance.
 555   \return      pointer to rsa instance
 556 */
 557 int32_t target_get_rsa(int32_t idx, uint32_t *base, uint32_t *irq)
 558 {
 559     if (idx >= target_get_rsa_count()) {
 560         return NULL;
 561     }
 562
 563     *base = sg_rsa_config[idx].base;
 564     *irq = sg_rsa_config[idx].irq;
 565     return idx;
 566 }
 567
 568 #endif
 569
 570 #if CONFIG_RTC
 571 struct {
 572     uint32_t base;
 573     uint32_t irq;
 574 }
 575 const sg_rtc_config[CONFIG_RTC_NUM] = {
 576     {CSKY_RTC_BASE, RTC_IRQn}
 577 };
 578
 579 int32_t target_get_rtc_count(void)
 580 {
 581     return CONFIG_RTC_NUM;
 582 }
 583
 584 int32_t target_get_rtc(int32_t idx, uint32_t *base, uint32_t *irq)
 585 {
 586     if (idx >= target_get_rtc_count()) {
 587         return NULL;
 588     }
 589
 590     *base = sg_rtc_config[idx].base;
 591     *irq = sg_rtc_config[idx].irq;
 592     return idx;
 593 }
 594
 595 #endif
 596
 597 #if CONFIG_SPI
 598 struct {
 599     uint32_t base;
 600     uint32_t irq;
 601 }
 602
 603 const sg_spi_config[CONFIG_SPI_NUM] = {
 604     {CSKY_SPI0_BASE, SPI0_IRQn},
 605     {CSKY_SPI1_BASE, SPI1_IRQn}
 606 };
 607 typedef struct {
 608     pin_t    mosi;
 609     pin_t    miso;
 610     pin_t    sclk;
 611     pin_t    ssel;
 612     uint32_t cfg_idx;    //idx of sg_iic_config[]
 613     uint16_t function;
 614 } spi_pin_map_t;
 615 const static spi_pin_map_t s_spi_pin_map[] = {
 616     {
 617         PA7_SPI0TX_PWMTRIG1_SDA0_XX,
 618         PA8_SPI0RX_TRIGFAULT_SCL1_XX,
 619         PA6_SPI0CLK_PWMTRIG0_SCL0_XX,
 620         PA9_SPI0CS_PWM0_SDA1_XX,
 621         0,
 622         0
 623     },
 624     {
 625         PA17_SPI1TX_PWMFAULT_XX_XX,
 626         PA18_SPI1RX_PWM0_XX_XX,
 627         PA16_SPI1CLK_PWMTRIG1_XX_XX,
 628         PA19_SPI1CS0_PWM1_XX_XX,
 629         1,
 630         0
 631     },
 632     {
 633         PA13_RTS1_PWM4_SPI1TX_XX,
 634         PA14_SCL1_PWM5_SPI1RX_XX,
 635         PA12_CTS1_PWM3_SPI1CLK_XX,
 636         PA15_SDA1_PWMTRIG0_SPI1CS0_XX,
 637         1,
 638         2
 639     },
 640     {
 641         PB4_ADC4_SPI1TX_USINSS_XX,
 642         PB5_ADC5_SPI1RX_USISCLK_XX,
 643         PB3_ADC3_SPI1CLK_USISD1_XX,
 644         PB6_ADC6_SPI1CS0_USISD0_XX,
 645         1,
 646         1
 647     }
 648 };
 649
 650 /**
 651   \param[in]   instance idx, must not exceed return value of target_get_spi_count()
 652   \brief       get spi instance.
 653   \return      pointer to spi instance
 654 */
 655 int32_t target_spi_init(pin_t mosi, pin_t miso, pin_t sclk, pin_t ssel, uint32_t *base, uint32_t *irq)
 656 {
 657     uint32_t idx;
 658
 659     for (idx = 0; idx < sizeof(s_spi_pin_map) / sizeof(spi_pin_map_t); idx++) {
 660         if (s_spi_pin_map[idx].mosi == mosi && s_spi_pin_map[idx].miso == miso
 661             && s_spi_pin_map[idx].sclk == sclk && s_spi_pin_map[idx].ssel == ssel) {
 662             *base = sg_spi_config[s_spi_pin_map[idx].cfg_idx].base;
 663             *irq = sg_spi_config[s_spi_pin_map[idx].cfg_idx].irq;
 664             /*pinmux*/
 665             pin_mux(s_spi_pin_map[idx].mosi, s_spi_pin_map[idx].function);
 666             pin_mux(s_spi_pin_map[idx].miso, s_spi_pin_map[idx].function);
 667             pin_mux(s_spi_pin_map[idx].sclk, s_spi_pin_map[idx].function);
 668             pin_mux(s_spi_pin_map[idx].ssel, s_spi_pin_map[idx].function);
 669
 670             return s_spi_pin_map[idx].cfg_idx;
 671         }
 672     }
 673
 674     return -1;
 675
 676 }
 677
 678 #endif
 679
 680 #if CONFIG_WDT
 681 struct {
 682     uint32_t base;
 683     uint32_t irq;
 684 }
 685 const sg_wdt_config[CONFIG_WDT_NUM] = {
 686     {CSKY_WDT_BASE, WDT_IRQn}
 687 };
 688
 689 int32_t target_get_wdt_count(void)
 690 {
 691     return CONFIG_WDT_NUM;
 692 }
 693
 694 int32_t target_get_wdt(int32_t idx, uint32_t *base, uint32_t *irq)
 695 {
 696     if (idx >= target_get_wdt_count()) {
 697         return NULL;
 698     }
 699
 700     *base = sg_wdt_config[idx].base;
 701     *irq = sg_wdt_config[idx].irq;
 702     return idx;
 703 }
 704 #endif
 705
 706
 707 #if CONFIG_SHA
 708 struct {
 709     uint32_t base;
 710     uint32_t irq;
 711 }
 712 const sg_sha_config[CONFIG_SHA_NUM] = {
 713     {CSKY_SHA_BASE, SHA_IRQn}
 714 };
 715
 716 /**
 717   \brief       get sha instance count.
 718   \return      sha instance count
 719 */
 720 int32_t target_get_sha_count(void)
 721 {
 722     return CONFIG_SHA_NUM;
 723 }
 724
 725 /**
 726   \param[in]   instance idx, must not exceed return value of target_get_sha_count()
 727   \brief       get sha instance.
 728   \return      pointer to sha instance
 729 */
 730 int32_t target_get_sha(int32_t idx, uint32_t *base, uint32_t *irq)
 731 {
 732     if (idx >= target_get_sha_count()) {
 733         return NULL;
 734     }
 735
 736     *base = sg_sha_config[idx].base;
 737     *irq = sg_sha_config[idx].irq;
 738     return idx;
 739 }
 740
 741 #endif
 742
 743 #if CONFIG_PWM
 744 struct {
 745     uint32_t base;
 746     uint32_t irq;
 747 }
 748 const sg_pwm_config[CONFIG_PWM_NUM] = {
 749     {CSKY_PWM_BASE, PWM_IRQn},
 750 };
 751
 752 typedef struct {
 753     pin_t    pwm_pin;
 754     uint32_t cfg_idx;    //idx of sg_pwm_config[]
 755     uint32_t ch_num;
 756     uint16_t function;
 757 } pwm_pin_map_t;
 758 const static pwm_pin_map_t s_pwm_pin_map[] = {
 759     {PA0_TXD0_PWM0_XX_SIROUT0, 0, 0, 1},
 760     {PA9_SPI0CS_PWM0_SDA1_XX, 0, 0, 1},
 761     {PA18_SPI1RX_PWM0_XX_XX, 0, 0, 1},
 762     {PA27_RXD3_PWM0_XX_SIRIN3, 0, 0, 1},
 763
 764     {PA1_RXD0_PWM1_XX_SIRIN0, 0, 1, 1},
 765     {PA10_TXD1_PWM1_XX_SIROUT1, 0, 1, 1},
 766     {PA19_SPI1CS0_PWM1_XX_XX, 0, 1, 1},
 767     {PA28_I2SMCLK_PWM1_XX_XX, 0, 1, 1},
 768
 769     {PA2_CTS0_PWM2_SPI0CLK_XX, 0, 2, 1},
 770     {PA11_RXD1_PWM2_XX_SIRIN1, 0, 2, 1},
 771     {PA20_SPI1CS1_PWM2_XX_XX, 0, 2, 1},
 772     {PA29_I2SSCLK_PWM2_XX_XX, 0, 2, 1},
 773
 774     {PA3_RTS0_PWM3_SPI0TX_XX, 0, 3, 1},
 775     {PA12_CTS1_PWM3_SPI1CLK_XX, 0, 3, 1},
 776     {PA21_SPI1CS2_PWM3_XX_XX, 0, 3, 1},
 777     {PA30_I2SWSCLK_PWM3_XX_XX, 0, 3, 1},
 778
 779     {PA4_SCL0_PWM4_SPI0RX_XX, 0, 4, 1},
 780     {PA13_RTS1_PWM4_SPI1TX_XX, 0, 4, 1},
 781     {PA22_RXD2_PWM4_XX_SIRIN2, 0, 4, 1},
 782     {PA31_I2SSDA__SCL0_PWM4_XX, 0, 4, 1},
 783
 784     {PA5_SDA0_PWM5_SPI0CS_XX, 0, 5, 1},
 785     {PA14_SCL1_PWM5_SPI1RX_XX, 0, 5, 1},
 786     {PA23_TXD2_PWM5_XX_SIROUT2, 0, 5, 1},
 787     {PB0_ADC0_SDA0_PWM5_XX, 0, 5, 1},
 788 };
 789
 790 /**
 791   \param[in]   instance idx, must not exceed return value of target_get_pwm_count()
 792   \brief       get pwm instance.
 793   \return      pointer to pwm instance
 794 */
 795 int32_t target_pwm_init(pin_t pwm_pin, uint32_t *ch_num, uint32_t *base, uint32_t *irq)
 796 {
 797     uint32_t idx;
 798
 799     for (idx = 0; idx < sizeof(s_pwm_pin_map) / sizeof(pwm_pin_map_t); idx++) {
 800         if (s_pwm_pin_map[idx].pwm_pin == pwm_pin) {
 801             *base = sg_pwm_config[s_pwm_pin_map[idx].cfg_idx].base;
 802             *irq = sg_pwm_config[s_pwm_pin_map[idx].cfg_idx].irq;
 803             *ch_num = s_pwm_pin_map[idx].ch_num;
 804             /*pinmux*/
 805             pin_mux(s_pwm_pin_map[idx].pwm_pin, s_pwm_pin_map[idx].function);
 806             return s_pwm_pin_map[idx].cfg_idx;
 807         }
 808     }
 809
 810     return -1;
 811
 812 }
 813
 814
 815 #endif
 816
 817
 818 #if CONFIG_DMAC
 819 struct {
 820     uint32_t base;
 821     uint32_t irq;
 822 }
 823 const sg_dmac_config[CONFIG_DMAC_NUM] = {
 824     {CSKY_DMA_BASE, DMAC_IRQn},
 825 };
 826
 827 int32_t target_get_dmac_count(void)
 828 {
 829     return CONFIG_DMAC_NUM;
 830 }
 831
 832 int32_t target_get_dmac(int32_t idx, uint32_t *base, uint32_t *irq)
 833 {
 834     if (idx >= target_get_dmac_count()) {
 835         return NULL;
 836     }
 837
 838     *base = sg_dmac_config[idx].base;
 839     *irq = sg_dmac_config[idx].irq;
 840     return idx;
 841 }
 842 #endif
 843