ssif_int.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 * Copyright (C) 2013-2014 Renesas Electronics Corporation. All rights reserved.
00022 *******************************************************************************/
00023 
00024 /*******************************************************************************
00025 * File Name   : ssif_int.c
00026 * $Rev: 891 $
00027 * $Date:: 2014-06-27 10:40:52 +0900#$
00028 * Description : SSIF driver interrupt functions
00029 ******************************************************************************/
00030 
00031 /*******************************************************************************
00032 Includes <System Includes>, "Project Includes"
00033 *******************************************************************************/
00034 #include "ssif.h"
00035 #include "ssif_int.h"
00036 #include "Renesas_RZ_A1.h"
00037 #include "gic.h"
00038 
00039 /*******************************************************************************
00040 Typedef definitions
00041 *******************************************************************************/
00042 
00043 
00044 /*******************************************************************************
00045 Macro definitions
00046 *******************************************************************************/
00047 #define SSIF_INT_PER_CH     (4u)
00048 
00049 
00050 /*******************************************************************************
00051 Private global variables and functions
00052 *******************************************************************************/
00053 
00054 /******************************************************************************
00055  Function prototypes
00056  *****************************************************************************/
00057 
00058 static void SSIF_ERI0_Handler(void);
00059 static void SSIF_ERI1_Handler(void);
00060 static void SSIF_ERI2_Handler(void);
00061 static void SSIF_ERI3_Handler(void);
00062 static void SSIF_ERI4_Handler(void);
00063 static void SSIF_ERI5_Handler(void);
00064 
00065 static void SSIF_ERI_Handler(const uint32_t ssif_ch);
00066 
00067 /******************************************************************************
00068 * Function Name: SSIF_InterruptInit
00069 * @brief         Initialize interrupt setting for SSIF channel.
00070 *
00071 *                Description:<br>
00072 *                Enable interrupt and register interrupt handler.
00073 * @param[in]     ssif_ch    :SSIF channel
00074 * @param[in]     int_level  :GIC priority level of interrupt
00075 * @retval        none
00076 ******************************************************************************/
00077 void SSIF_InterruptInit(const uint32_t ssif_ch, const uint8_t int_level)
00078 {
00079     uint32_t ret;
00080 
00081     switch (ssif_ch)
00082     {
00083         case SSIF_CHNUM_0:
00084             ret = InterruptHandlerRegister(SSII0_IRQn, &SSIF_ERI0_Handler);
00085             if (0u != ret)
00086             {
00087                 /* NON_NOTICE_ASSERT: Illegal IRQ number */
00088             }
00089             GIC_SetPriority(SSII0_IRQn, int_level);
00090             GIC_SetPriority(SSIRXI0_IRQn, int_level);
00091             GIC_SetPriority(SSITXI0_IRQn, int_level);
00092             GIC_EnableIRQ(SSII0_IRQn);
00093             GIC_EnableIRQ(SSIRXI0_IRQn);
00094             GIC_EnableIRQ(SSITXI0_IRQn);
00095             break;
00096         case SSIF_CHNUM_1:
00097             ret = InterruptHandlerRegister(SSII1_IRQn, &SSIF_ERI1_Handler);
00098             if (0u != ret)
00099             {
00100                 /* NON_NOTICE_ASSERT: Illegal IRQ number */
00101             }
00102             GIC_SetPriority(SSII1_IRQn, int_level);
00103             GIC_SetPriority(SSIRXI1_IRQn, int_level);
00104             GIC_SetPriority(SSITXI1_IRQn, int_level);
00105             GIC_EnableIRQ(SSII1_IRQn);
00106             GIC_EnableIRQ(SSIRXI1_IRQn);
00107             GIC_EnableIRQ(SSITXI1_IRQn);
00108             break;
00109         case SSIF_CHNUM_2:
00110             ret = InterruptHandlerRegister(SSII2_IRQn, &SSIF_ERI2_Handler);
00111             if (0u != ret)
00112             {
00113                 /* NON_NOTICE_ASSERT: Illegal IRQ number */
00114             }
00115             GIC_SetPriority(SSII2_IRQn, int_level);
00116             GIC_SetPriority(SSIRTI2_IRQn, int_level);
00117             GIC_EnableIRQ(SSII2_IRQn);
00118             GIC_EnableIRQ(SSIRTI2_IRQn);
00119             break;
00120         case SSIF_CHNUM_3:
00121             ret = InterruptHandlerRegister(SSII3_IRQn, &SSIF_ERI3_Handler);
00122             if (0u != ret)
00123             {
00124                 /* NON_NOTICE_ASSERT: Illegal IRQ number */
00125             }
00126             GIC_SetPriority(SSII3_IRQn, int_level);
00127             GIC_SetPriority(SSIRXI3_IRQn, int_level);
00128             GIC_SetPriority(SSITXI3_IRQn, int_level);
00129             GIC_EnableIRQ(SSII3_IRQn);
00130             GIC_EnableIRQ(SSIRXI3_IRQn);
00131             GIC_EnableIRQ(SSITXI3_IRQn);
00132             break;
00133         case SSIF_CHNUM_4:
00134             ret = InterruptHandlerRegister(SSII4_IRQn, &SSIF_ERI4_Handler);
00135             if (0u != ret)
00136             {
00137                 /* NON_NOTICE_ASSERT: Illegal IRQ number */
00138             }
00139             GIC_SetPriority(SSII4_IRQn, int_level);
00140             GIC_SetPriority(SSIRTI4_IRQn, int_level);
00141             GIC_EnableIRQ(SSII4_IRQn);
00142             GIC_EnableIRQ(SSIRTI4_IRQn);
00143             break;
00144         case SSIF_CHNUM_5:
00145             ret = InterruptHandlerRegister(SSII5_IRQn, &SSIF_ERI5_Handler);
00146             if (0u != ret)
00147             {
00148                 /* NON_NOTICE_ASSERT: Illegal IRQ number */
00149             }
00150             GIC_SetPriority(SSII5_IRQn, int_level);
00151             GIC_SetPriority(SSIRXI5_IRQn, int_level);
00152             GIC_SetPriority(SSITXI5_IRQn, int_level);
00153             GIC_EnableIRQ(SSII5_IRQn);
00154             GIC_EnableIRQ(SSIRXI5_IRQn);
00155             GIC_EnableIRQ(SSITXI5_IRQn);
00156             break;
00157         /* ->IPA R3.5.2 : There is nothing to do when unusual conditons. */
00158         default:
00159             /* NON_NOTICE_ASSERT: Illegal channel number */
00160             break;
00161         /* <-IPA R3.5.2 */
00162     }
00163 
00164     return;
00165 }
00166 
00167 /******************************************************************************
00168 * Function Name: SSIF_InterruptShutdown
00169 * @brief         Uninitialize interrupt setting for SSIF channel.
00170 *
00171 *                Description:<br>
00172 *                Disable interrupt and unregister interrupt handler 
00173 * @param[in]     ssif_ch    :SSIF channel
00174 * @retval        none
00175 ******************************************************************************/
00176 void SSIF_InterruptShutdown(const uint32_t ssif_ch)
00177 {
00178     uint32_t ret;
00179 
00180     switch (ssif_ch)
00181     {
00182         case SSIF_CHNUM_0:
00183             GIC_DisableIRQ(SSII0_IRQn);
00184             GIC_DisableIRQ(SSIRXI0_IRQn);
00185             GIC_DisableIRQ(SSITXI0_IRQn);
00186             ret = InterruptHandlerUnregister(SSII0_IRQn);
00187             if (0u != ret)
00188             {
00189                 /* NON_NOTICE_ASSERT: Illegal IRQ number */
00190             }
00191             break;
00192         case SSIF_CHNUM_1:
00193             GIC_DisableIRQ(SSII1_IRQn);
00194             GIC_DisableIRQ(SSIRXI1_IRQn);
00195             GIC_DisableIRQ(SSITXI1_IRQn);
00196             ret = InterruptHandlerUnregister(SSII1_IRQn);
00197             if (0u != ret)
00198             {
00199                 /* NON_NOTICE_ASSERT: Illegal IRQ number */
00200             }
00201             break;
00202         case SSIF_CHNUM_2:
00203             GIC_DisableIRQ(SSII2_IRQn);
00204             GIC_DisableIRQ(SSIRTI2_IRQn);
00205             ret = InterruptHandlerUnregister(SSII2_IRQn);
00206             if (0u != ret)
00207             {
00208                 /* NON_NOTICE_ASSERT: Illegal IRQ number */
00209             }
00210             break;
00211         case SSIF_CHNUM_3:
00212             GIC_DisableIRQ(SSII3_IRQn);
00213             GIC_DisableIRQ(SSIRXI3_IRQn);
00214             GIC_DisableIRQ(SSITXI3_IRQn);
00215             ret = InterruptHandlerUnregister(SSII3_IRQn);
00216             if (0u != ret)
00217             {
00218                 /* NON_NOTICE_ASSERT: Illegal IRQ number */
00219             }
00220             break;
00221         case SSIF_CHNUM_4:
00222             GIC_DisableIRQ(SSII4_IRQn);
00223             GIC_DisableIRQ(SSIRTI4_IRQn);
00224             ret = InterruptHandlerUnregister(SSII4_IRQn);
00225             if (0u != ret)
00226             {
00227                 /* NON_NOTICE_ASSERT: Illegal IRQ number */
00228             }
00229             break;
00230         case SSIF_CHNUM_5:
00231             GIC_DisableIRQ(SSII5_IRQn);
00232             GIC_DisableIRQ(SSIRXI5_IRQn);
00233             GIC_DisableIRQ(SSITXI5_IRQn);
00234             ret = InterruptHandlerUnregister(SSII5_IRQn);
00235             if (0u != ret)
00236             {
00237                 /* NON_NOTICE_ASSERT: Illegal IRQ number */
00238             }
00239             break;
00240         /* ->IPA R3.5.2 : There is nothing to do when unusual conditons. */
00241         default:
00242             /* NON_NOTICE_ASSERT: Illegal channel number */
00243             break;
00244         /* <-IPA R3.5.2 */
00245     }
00246 
00247     return;
00248 }
00249 
00250 /******************************************************************************
00251 * Function Name: SSIF_EnableErrorInterrupt
00252 * @brief         Enable the SSIF channel error interrupt
00253 *
00254 *                Description:<br>
00255 *                
00256 * @param[in]     ssif_ch    :SSIF channel
00257 * @retval        none
00258 ******************************************************************************/
00259 void SSIF_EnableErrorInterrupt(const uint32_t ssif_ch)
00260 {
00261     /* clear error status */
00262     g_ssireg[ssif_ch]->SSISR = 0u;
00263 
00264     /* enable error interrupt */
00265     g_ssireg[ssif_ch]->SSICR |= SSIF_CR_INT_ERR_MASK;
00266  
00267     return;
00268 }
00269 
00270 /******************************************************************************
00271 * Function Name: SSIF_DisableErrorInterrupt
00272 * @brief         Disable the SSIF channel error interrupt
00273 *
00274 *                Description:<br>
00275 *                
00276 * @param[in]     ssif_ch    :SSIF channel
00277 * @retval        none
00278 ******************************************************************************/
00279 void SSIF_DisableErrorInterrupt(const uint32_t ssif_ch)
00280 {
00281     /* disable error interrupt */
00282     g_ssireg[ssif_ch]->SSICR &= ~(SSIF_CR_INT_ERR_MASK);
00283 
00284     return;
00285 }
00286 
00287 /******************************************************************************
00288 * Function Name: SSIF_ERI<n>_Handler
00289 * @brief         SSIF error interrupt handler per channel
00290 *
00291 *                Description:<br>
00292 *                
00293 * @param         none
00294 * @retval        none
00295 ******************************************************************************/
00296 
00297 static void SSIF_ERI0_Handler(void)
00298 {
00299     SSIF_ERI_Handler(SSIF_CHNUM_0);
00300     return;
00301 }
00302 
00303 static void SSIF_ERI1_Handler(void)
00304 {
00305     SSIF_ERI_Handler(SSIF_CHNUM_1);
00306     return;
00307 }
00308 
00309 static void SSIF_ERI2_Handler(void)
00310 {
00311     SSIF_ERI_Handler(SSIF_CHNUM_2);
00312     return;
00313 }
00314 
00315 static void SSIF_ERI3_Handler(void)
00316 {
00317     SSIF_ERI_Handler(SSIF_CHNUM_3);
00318     return;
00319 }
00320 
00321 static void SSIF_ERI4_Handler(void)
00322 {
00323     SSIF_ERI_Handler(SSIF_CHNUM_4);
00324     return;
00325 }
00326 
00327 static void SSIF_ERI5_Handler(void)
00328 {
00329     SSIF_ERI_Handler(SSIF_CHNUM_5);
00330     return;
00331 }
00332 
00333 /******************************************************************************
00334 * Function Name: SSIF_ERI_Handler
00335 * @brief         SSIF error interrupt handler common function
00336 *
00337 *                Description:<br>
00338 *                
00339 * @param[in]     ssif_ch    :SSIF channel
00340 * @retval        none
00341 ******************************************************************************/
00342 
00343 static void SSIF_ERI_Handler(const uint32_t ssif_ch)
00344 {
00345     ssif_info_ch_t* const p_info_ch = &g_ssif_info_drv.info_ch[ssif_ch];
00346 
00347     if (0u != (g_ssireg[ssif_ch]->SSISR & SSIF_SR_INT_ERR_MASK))
00348     {
00349         /* Restart or Callback */
00350         SSIF_ErrorRecovery(p_info_ch);
00351     }
00352 
00353     return;
00354 }