void SDIO_IRQHandler()

in lib/cmsis/CMSIS/Pack/Example/CMSIS_Driver/MCI_LPC18xx.c [845:998]

• 126 lines of code
• 28 McCabe index (conditional complexity)

void SDIO_IRQHandler (void) {
  uint32_t rintsts, idsts;
  uint32_t rintclr, idclr;
  uint32_t event, mask;

  event   = 0;
  rintclr = 0;
  idclr   = 0;
  rintsts = LPC_SDMMC->RINTSTS;
  idsts   = LPC_SDMMC->IDSTS;

  /* Abnormal Interrupt Summary */
  if (idsts & SDMMC_IDSTS_DU) {
    idclr |= SDMMC_IDSTS_DU;
    /* Descriptor Unavailable Interrupt */
    if (MCI.xfer.cnt) {
      SetupDMADescriptor (&MCI.xfer, false);

      LPC_SDMMC->PLDMND = 1;
    }
  }
  if (idsts & SDMMC_IDSTS_FBE) {
    idclr |= SDMMC_IDSTS_FBE;
    /* Fatal Bus Error Interrupt */
    event |= ARM_MCI_EVENT_TRANSFER_ERROR;
  }
  #if (RTE_SD_CD_PIN_EN)
  if (rintsts & SDMMC_RINTSTS_CDET) {
    rintclr |= SDMMC_RINTSTS_CDET;
    /* Card detect */
    if (LPC_SDMMC->CDETECT & 1) {
      event |= ARM_MCI_EVENT_CARD_REMOVED;
    }
    else {
      event |= ARM_MCI_EVENT_CARD_INSERTED;
    }
  }
  #endif
  if (rintsts & SDMMC_RINTSTS_RE) {
    rintclr |= SDMMC_RINTSTS_RE;
    /* Response error */
    event |= ARM_MCI_EVENT_COMMAND_ERROR;
  }
  if (rintsts & SDMMC_RINTSTS_CDONE) {
    rintclr |= SDMMC_RINTSTS_CDONE;
    /* Command done */
    event |= ARM_MCI_EVENT_COMMAND_COMPLETE;

    if (MCI.response) {
      /* Read response registers */
      MCI.response[0] = LPC_SDMMC->RESP0;

      if (MCI.flags & MCI_RESP_LONG) {
        MCI.response[1] = LPC_SDMMC->RESP1;
        MCI.response[2] = LPC_SDMMC->RESP2;
        MCI.response[3] = LPC_SDMMC->RESP3;
      }
    }
  }
  if (rintsts & SDMMC_RINTSTS_DTO) {
    rintclr |= SDMMC_RINTSTS_DTO;
    /* Data transfer over */
    event |= ARM_MCI_EVENT_TRANSFER_COMPLETE;
  }
  if (rintsts & SDMMC_RINTSTS_RCRC) {
    rintclr |= SDMMC_RINTSTS_RCRC;
    /* Response CRC error */
    event |= ARM_MCI_EVENT_COMMAND_ERROR;
  }
  if (rintsts & SDMMC_RINTSTS_DCRC) {
    rintclr |= SDMMC_RINTSTS_DCRC;
    /* Data CRC error */
    event |= ARM_MCI_EVENT_TRANSFER_ERROR;
  }
  if (rintsts & SDMMC_RINTSTS_RTO_BAR) {
    rintclr |= SDMMC_RINTSTS_RTO_BAR;
    /* Response time-out/Boot Ack Received */
    event |= ARM_MCI_EVENT_COMMAND_TIMEOUT;
  }
  if (rintsts & SDMMC_RINTSTS_DRTO_BDS) {
    rintclr |= SDMMC_RINTSTS_DRTO_BDS;
    /* Data read time-out / Boot Data Start              */
    /* Card has not sent data within the time-out period */
    event |= ARM_MCI_EVENT_TRANSFER_TIMEOUT;
  }
  if (rintsts & SDMMC_RINTSTS_HLE) {
    rintclr |= SDMMC_RINTSTS_HLE;
    /* Hardware locked error (command buffer full) */
    event |= ARM_MCI_EVENT_COMMAND_ERROR;
  }
  if (rintsts & SDMMC_RINTSTS_SBE) {
    rintclr |= SDMMC_RINTSTS_SBE;
    /* Start-bit error */
    event |= ARM_MCI_EVENT_TRANSFER_ERROR;
  }
  if (rintsts & SDMMC_RINTSTS_EBE) {
    rintclr |= SDMMC_RINTSTS_EBE;
    /* End-bit error (read)/write no CRC */
    event |= ARM_MCI_EVENT_TRANSFER_ERROR;
  }
  if (rintsts & SDMMC_RINTSTS_SDIO_INTERRUPT) {
    rintclr |= SDMMC_RINTSTS_SDIO_INTERRUPT;
    /* Interrupt from SDIO card */
    event |= ARM_MCI_EVENT_SDIO_INTERRUPT;
    MCI.status.sdio_interrupt = 1;

    /* Disable interrupt (must be re-enabled using Control) */
    LPC_SDMMC->INTMASK &= ~SDMMC_INTMASK_SDIO_INT_MASK;
  }

  LPC_SDMMC->RINTSTS = rintclr;
  LPC_SDMMC->IDSTS   = idclr;

  if (event && MCI.cb_event) {
    mask = ARM_MCI_EVENT_TRANSFER_ERROR   |
           ARM_MCI_EVENT_TRANSFER_TIMEOUT |
           ARM_MCI_EVENT_TRANSFER_COMPLETE;
    if (event & mask) {
      MCI.status.transfer_active = 0;

      if (event & ARM_MCI_EVENT_TRANSFER_ERROR) {
        (MCI.cb_event)(ARM_MCI_EVENT_TRANSFER_ERROR);
      }
      else if (event & ARM_MCI_EVENT_TRANSFER_TIMEOUT) {
        (MCI.cb_event)(ARM_MCI_EVENT_TRANSFER_TIMEOUT);
      }
      else {
        (MCI.cb_event)(ARM_MCI_EVENT_TRANSFER_COMPLETE);
      }
    }
    mask = ARM_MCI_EVENT_COMMAND_ERROR   |
           ARM_MCI_EVENT_COMMAND_TIMEOUT |
           ARM_MCI_EVENT_COMMAND_COMPLETE;
    if (event & mask) {
      MCI.status.command_active = 0;

      if (event & ARM_MCI_EVENT_COMMAND_ERROR) {
        (MCI.cb_event)(ARM_MCI_EVENT_COMMAND_ERROR);
      }
      else if (event & ARM_MCI_EVENT_COMMAND_TIMEOUT) {
        (MCI.cb_event)(ARM_MCI_EVENT_COMMAND_TIMEOUT);
      }
      else {
        (MCI.cb_event)(ARM_MCI_EVENT_COMMAND_COMPLETE);
      }
    }
    mask = ARM_MCI_EVENT_CARD_INSERTED |
           ARM_MCI_EVENT_CARD_REMOVED  |
           ARM_MCI_EVENT_SDIO_INTERRUPT;
    if (event & mask) {
      (MCI.cb_event)(event & mask);
    }
  }
}