#define RCC    ((uint8_t *)  0xcccccccc) // неважен смысл и где это все

typedef struct
{
....
uint8_t GRH;
.....
} SPI_TypedefChto_totam;

RCC->GRH =.....

#define RCC    ((uint8_t *)  0xcccccccc)

typedef struct
{
 uint8_t Data_buff[512];

}SPI_Data_BuffType;



void DMA_ACCUM ()
{
    uint8_t Data;
HAL_SPI_Receive_DMA (&hspi1, &Data, 1);
   
    Pointer->Data_buff[0] = Data;     // pointer задан дефайном, как указал ранее.
   
}

#define Pointer  ((uint8_t *)  0xcccccccc)

HAL_SPI_Receive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size)
{
  HAL_StatusTypeDef errorcode = HAL_OK;

  if((hspi->Init.Direction == SPI_DIRECTION_2LINES)&&(hspi->Init.Mode == SPI_MODE_MASTER))
  {
     hspi->State = HAL_SPI_STATE_BUSY_RX;
     /* Call transmit-receive function to send Dummy data on Tx line and generate clock on CLK line */
     return HAL_SPI_TransmitReceive_DMA(hspi, pData, pData, Size);
  }

  /* Process Locked */
  __HAL_LOCK(hspi);

  if(hspi->State != HAL_SPI_STATE_READY)
  {
    errorcode = HAL_BUSY;
    goto error;
  }

  if((pData == NULL) || (Size == 0U))
  {
    errorcode = HAL_ERROR;
    goto error;
  }

  /* Set the transaction information */
  hspi->State       = HAL_SPI_STATE_BUSY_RX;
  hspi->ErrorCode   = HAL_SPI_ERROR_NONE;
  hspi->pRxBuffPtr  = (uint8_t *)pData;
  hspi->RxXferSize  = Size;
  hspi->RxXferCount = Size;

  /*Init field not used in handle to zero */
  hspi->RxISR       = NULL;
  hspi->TxISR       = NULL;
  hspi->TxXferSize  = 0U;
  hspi->TxXferCount = 0U;

  /* Configure communication direction : 1Line */
  if(hspi->Init.Direction == SPI_DIRECTION_1LINE)
  {
    SPI_1LINE_RX(hspi);
  }

#if (USE_SPI_CRC != 0U)
  /* Reset CRC Calculation */
  if(hspi->Init.CRCCalculation == SPI_CRCCALCULATION_ENABLE)
  {
    SPI_RESET_CRC(hspi);
  }
#endif /* USE_SPI_CRC */

  /* Set the SPI RxDMA Half transfer complete callback */
  hspi->hdmarx->XferHalfCpltCallback = SPI_DMAHalfReceiveCplt;

  /* Set the SPI Rx DMA transfer complete callback */
  hspi->hdmarx->XferCpltCallback = SPI_DMAReceiveCplt;

  /* Set the DMA error callback */
  hspi->hdmarx->XferErrorCallback = SPI_DMAError;

 /* Set the DMA AbortCpltCallback */
  hspi->hdmarx->XferAbortCallback = NULL;

  /* Enable the Rx DMA Stream */
  HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->DR, (uint32_t)hspi->pRxBuffPtr, hspi->RxXferCount);

  /* Check if the SPI is already enabled */
  if((hspi->Instance->CR1 &SPI_CR1_SPE) != SPI_CR1_SPE)
  {
    /* Enable SPI peripheral */
    __HAL_SPI_ENABLE(hspi);
  }

  /* Enable the SPI Error Interrupt Bit */
  SET_BIT(hspi->Instance->CR2, SPI_CR2_ERRIE);

  /* Enable Rx DMA Request */
  SET_BIT(hspi->Instance->CR2, SPI_CR2_RXDMAEN);

error:
  /* Process Unlocked */
  __HAL_UNLOCK(hspi);
  return errorcode;
}

typedef struct __SPI_HandleTypeDef
{
  SPI_TypeDef                *Instance;    /*!< SPI registers base address */
  SPI_InitTypeDef            Init;         /*!< SPI communication parameters */
  uint8_t                    *pTxBuffPtr;  /*!< Pointer to SPI Tx transfer Buffer */
  uint16_t                   TxXferSize;   /*!< SPI Tx Transfer size */
  __IO uint16_t              TxXferCount;  /*!< SPI Tx Transfer Counter */
  uint8_t                    *pRxBuffPtr;  /*!< Pointer to SPI Rx transfer Buffer */
  uint16_t                   RxXferSize;   /*!< SPI Rx Transfer size */
  __IO uint16_t              RxXferCount;  /*!< SPI Rx Transfer Counter */
  void                       (*RxISR)(struct __SPI_HandleTypeDef * hspi); /*!< function pointer on Rx ISR */
  void                       (*TxISR)(struct __SPI_HandleTypeDef * hspi); /*!< function pointer on Tx ISR */
  DMA_HandleTypeDef          *hdmatx;      /*!< SPI Tx DMA Handle parameters   */
  DMA_HandleTypeDef          *hdmarx;      /*!< SPI Rx DMA Handle parameters   */
  HAL_LockTypeDef            Lock;         /*!< Locking object                 */
  __IO HAL_SPI_StateTypeDef  State;        /*!< SPI communication state */
  __IO uint32_t              ErrorCode;    /*!< SPI Error code */
}SPI_HandleTypeDef;

  /* Enable the Rx DMA Stream */
  HAL_DMA_Start_IT(hspi->hdmarx, (uint32_t)&hspi->Instance->DR, (uint32_t)hspi->pRxBuffPtr, hspi->RxXferCount);