text: #[doc = "Reader of register BGCR_EMMC_MODE"]
  pub type R = crate::R<u8, super::BGCR_EMMC_MODE>;
  #[doc = "Writer for register BGCR_EMMC_MODE"]
  pub type W = crate::W<u8, super::BGCR_EMMC_MODE>;
  #[doc = "Register BGCR_EMMC_MODE `reset()`'s with value 0"]
  impl crate::ResetValue for super::BGCR_EMMC_MODE {
      type Type = u8;
      #[inline(always)]
      fn reset_value() -> Self::Type {
          0
      }
  }
  #[doc = "Stop at Block Gap Request\n\nValue on reset: 0"]
  #[derive(Clone, Copy, Debug, PartialEq)]
  pub enum STPBGR_A {
      #[doc = "0: Transfer"]
      TRANSFER = 0,
      #[doc = "1: Stop"]
      STOP = 1,
  }
  impl From<STPBGR_A> for bool {
      #[inline(always)]
      fn from(variant: STPBGR_A) -> Self {
          variant as u8 != 0
      }
  }
  #[doc = "Reader of field `STPBGR`"]
  pub type STPBGR_R = crate::R<bool, STPBGR_A>;
  impl STPBGR_R {
      #[doc = r"Get enumerated values variant"]
      #[inline(always)]
      pub fn variant(&self) -> STPBGR_A {
          match self.bits {
              false => STPBGR_A::TRANSFER,
              true => STPBGR_A::STOP,
          }
      }
      #[doc = "Checks if the value of the field is `TRANSFER`"]
      #[inline(always)]
      pub fn is_transfer(&self) -> bool {
          *self == STPBGR_A::TRANSFER
      }
      #[doc = "Checks if the value of the field is `STOP`"]
      #[inline(always)]
      pub fn is_stop(&self) -> bool {
          *self == STPBGR_A::STOP
      }
  }
  #[doc = "Write proxy for field `STPBGR`"]
  pub struct STPBGR_W<'a> {
      w: &'a mut W,
  }
  impl<'a> STPBGR_W<'a> {
      #[doc = r"Writes `variant` to the field"]
      #[inline(always)]
      pub fn variant(self, variant: STPBGR_A) -> &'a mut W {
          {
              self.bit(variant.into())
          }
      }
      #[doc = "Transfer"]
      #[inline(always)]
      pub fn transfer(self) -> &'a mut W {
          self.variant(STPBGR_A::TRANSFER)
      }
      #[doc = "Stop"]
      #[inline(always)]
      pub fn stop(self) -> &'a mut W {
          self.variant(STPBGR_A::STOP)
      }
      #[doc = r"Sets the field bit"]
      #[inline(always)]
      pub fn set_bit(self) -> &'a mut W {
          self.bit(true)
      }
      #[doc = r"Clears the field bit"]
      #[inline(always)]
      pub fn clear_bit(self) -> &'a mut W {
          self.bit(false)
      }
      #[doc = r"Writes raw bits to the field"]
      #[inline(always)]
      pub fn bit(self, value: bool) -> &'a mut W {
          self.w.bits = (self.w.bits & !0x01) | ((value as u8) & 0x01);
          self.w
      }
  }
  #[doc = "Continue Request\n\nValue on reset: 0"]
  #[derive(Clone, Copy, Debug, PartialEq)]
  pub enum CONTR_A {
      #[doc = "0: Not affected"]
      GO_ON = 0,
      #[doc = "1: Restart"]
      RESTART = 1,
  }
  impl From<CONTR_A> for bool {
      #[inline(always)]
      fn from(variant: CONTR_A) -> Self {
          variant as u8 != 0
      }
  }
  #[doc = "Reader of field `CONTR`"]
  pub type CONTR_R = crate::R<bool, CONTR_A>;
  impl CONTR_R {
      #[doc = r"Get enumerated values variant"]
      #[inline(always)]
      pub fn variant(&self) -> CONTR_A {
          match self.bits {
              false => CONTR_A::GO_ON,
              true => CONTR_A::RESTART,
          }
      }
      #[doc = "Checks if the value of the field is `GO_ON`"]
      #[inline(always)]
      pub fn is_go_on(&self) -> bool {
          *self == CONTR_A::GO_ON
      }
      #[doc = "Checks if the value of the field is `RESTART`"]
      #[inline(always)]
      pub fn is_restart(&self) -> bool {
          *self == CONTR_A::RESTART
      }
  }
  #[doc = "Write proxy for field `CONTR`"]
  pub struct CONTR_W<'a> {
      w: &'a mut W,
  }
  impl<'a> CONTR_W<'a> {
      #[doc = r"Writes `variant` to the field"]
      #[inline(always)]
      pub fn variant(self, variant: CONTR_A) -> &'a mut W {
          {
              self.bit(variant.into())
          }
      }
      #[doc = "Not affected"]
      #[inline(always)]
      pub fn go_on(self) -> &'a mut W {
          self.variant(CONTR_A::GO_ON)
      }
      #[doc = "Restart"]
      #[inline(always)]
      pub fn restart(self) -> &'a mut W {
          self.variant(CONTR_A::RESTART)
      }
      #[doc = r"Sets the field bit"]
      #[inline(always)]
      pub fn set_bit(self) -> &'a mut W {
          self.bit(true)
      }
      #[doc = r"Clears the field bit"]
      #[inline(always)]
      pub fn clear_bit(self) -> &'a mut W {
          self.bit(false)
      }
      #[doc = r"Writes raw bits to the field"]
      #[inline(always)]
      pub fn bit(self, value: bool) -> &'a mut W {
          self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u8) & 0x01) << 1);
          self.w
      }
  }
  impl R {
      #[doc = "Bit 0 - Stop at Block Gap Request"]
      #[inline(always)]
      pub fn stpbgr(&self) -> STPBGR_R {
          STPBGR_R::new((self.bits & 0x01) != 0)
      }
      #[doc = "Bit 1 - Continue Request"]
      #[inline(always)]
      pub fn contr(&self) -> CONTR_R {
          CONTR_R::new(((self.bits >> 1) & 0x01) != 0)
      }
  }
  impl W {
      #[doc = "Bit 0 - Stop at Block Gap Request"]
      #[inline(always)]
      pub fn stpbgr(&mut self) -> STPBGR_W {
          STPBGR_W { w: self }
      }
      #[doc = "Bit 1 - Continue Request"]
      #[inline(always)]
      pub fn contr(&mut self) -> CONTR_W {
          CONTR_W { w: self }
      }
  }
  