src/adc_stm32f103.c

   1 /*
   2  * adc_stm32f103.c - ADC driver for STM32F103
   3  *
   4  * Copyright (C) 2011, 2012, 2013 Free Software Initiative of Japan
   5  * Author: NIIBE Yutaka <gniibe@fsij.org>
   6  *
   7  * This file is a part of NeuG, a True Random Number Generator
   8  * implementation based on quantization error of ADC (for STM32F103).
   9  *
  10  * NeuG is free software: you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation, either version 3 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * NeuG is distributed in the hope that it will be useful, but WITHOUT
  16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  17  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  18  * License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  *
  23  */
  24
  25 #include <stdint.h>
  26 #include <stdlib.h>
  27 #include <chopstx.h>
  28
  29 #include "neug.h"
  30 #include "stm32f103.h"
  31 #include "adc.h"
  32
  33 #define NEUG_CRC32_COUNTS 4
  34
  35 #define STM32_ADC_ADC1_DMA_PRIORITY         2
  36
  37 #define ADC_SMPR1_SMP_VREF(n)   ((n) << 21)
  38 #define ADC_SMPR1_SMP_SENSOR(n) ((n) << 18)
  39
  40 #define ADC_SMPR1_SMP_AN10(n)   ((n) << 0)
  41 #define ADC_SMPR1_SMP_AN11(n)   ((n) << 3)
  42
  43 #define ADC_SMPR2_SMP_AN0(n)    ((n) << 0)
  44 #define ADC_SMPR2_SMP_AN1(n)    ((n) << 3)
  45 #define ADC_SMPR2_SMP_AN2(n)    ((n) << 6)
  46 #define ADC_SMPR2_SMP_AN9(n)    ((n) << 27)
  47
  48 #define ADC_SQR1_NUM_CH(n)      (((n) - 1) << 20)
  49
  50 #define ADC_SQR3_SQ1_N(n)       ((n) << 0)
  51 #define ADC_SQR3_SQ2_N(n)       ((n) << 5)
  52 #define ADC_SQR3_SQ3_N(n)       ((n) << 10)
  53 #define ADC_SQR3_SQ4_N(n)       ((n) << 15)
  54
  55 #define ADC_SAMPLE_1P5          0
  56
  57 #define ADC_CHANNEL_IN0         0
  58 #define ADC_CHANNEL_IN1         1
  59 #define ADC_CHANNEL_IN2         2
  60 #define ADC_CHANNEL_IN9         9
  61 #define ADC_CHANNEL_IN10        10
  62 #define ADC_CHANNEL_IN11        11
  63 #define ADC_CHANNEL_SENSOR      16
  64 #define ADC_CHANNEL_VREFINT     17
  65
  66 #define DELIBARATELY_DO_IT_WRONG_VREF_SAMPLE_TIME
  67 #define DELIBARATELY_DO_IT_WRONG_START_STOP
  68
  69 #ifdef DELIBARATELY_DO_IT_WRONG_VREF_SAMPLE_TIME
  70 #define ADC_SAMPLE_VREF ADC_SAMPLE_1P5
  71 #define ADC_SAMPLE_SENSOR ADC_SAMPLE_1P5
  72 #else
  73 #define ADC_SAMPLE_VREF ADC_SAMPLE_239P5
  74 #define ADC_SAMPLE_SENSOR ADC_SAMPLE_239P5
  75 #endif
  76
  77 #define NEUG_DMA_CHANNEL STM32_DMA1_STREAM1
  78 #define NEUG_DMA_MODE_SAMPLE                                            \
  79   (  STM32_DMA_CR_PL (STM32_ADC_ADC1_DMA_PRIORITY)                      \
  80      | STM32_DMA_CR_MSIZE_WORD | STM32_DMA_CR_PSIZE_WORD                \
  81      | STM32_DMA_CR_MINC       | STM32_DMA_CR_TCIE                      \
  82      | STM32_DMA_CR_TEIE)
  83
  84 #if 0
  85 #define NEUG_DMA_MODE_CRC32                                             \
  86   (  STM32_DMA_CR_PL (STM32_ADC_ADC1_DMA_PRIORITY)                      \
  87      | STM32_DMA_CR_MSIZE_WORD | STM32_DMA_CR_PSIZE_WORD                \
  88      | STM32_DMA_CR_TCIE       | STM32_DMA_CR_TEIE)
  89 #else
  90 #define NEUG_DMA_MODE_CRC32                                             \
  91   (  STM32_DMA_CR_PL (STM32_ADC_ADC1_DMA_PRIORITY)                      \
  92      | STM32_DMA_CR_MSIZE_WORD | STM32_DMA_CR_PSIZE_WORD                \
  93      | STM32_DMA_CR_MINC                                                \
  94      | STM32_DMA_CR_TCIE       | STM32_DMA_CR_TEIE)
  95 #endif
  96
  97 #define NEUG_ADC_SETTING1_SMPR1 ADC_SMPR1_SMP_VREF(ADC_SAMPLE_VREF)     \
  98                               | ADC_SMPR1_SMP_SENSOR(ADC_SAMPLE_SENSOR)
  99 #define NEUG_ADC_SETTING1_SMPR2 0
 100 #define NEUG_ADC_SETTING1_SQR3  ADC_SQR3_SQ1_N(ADC_CHANNEL_VREFINT)     \
 101                               | ADC_SQR3_SQ2_N(ADC_CHANNEL_SENSOR)      \
 102                               | ADC_SQR3_SQ3_N(ADC_CHANNEL_SENSOR)      \
 103                               | ADC_SQR3_SQ4_N(ADC_CHANNEL_VREFINT)
 104 #define NEUG_ADC_SETTING1_NUM_CHANNELS 4
 105
 106 #if !defined(NEUG_ADC_SETTING2_SMPR1)
 107 #define NEUG_ADC_SETTING2_SMPR1 0
 108 #define NEUG_ADC_SETTING2_SMPR2 ADC_SMPR2_SMP_AN0(ADC_SAMPLE_1P5)    \
 109                               | ADC_SMPR2_SMP_AN1(ADC_SAMPLE_1P5)
 110 #define NEUG_ADC_SETTING2_SQR3  ADC_SQR3_SQ1_N(ADC_CHANNEL_IN0)      \
 111                               | ADC_SQR3_SQ2_N(ADC_CHANNEL_IN1)
 112 #define NEUG_ADC_SETTING2_NUM_CHANNELS 2
 113 #endif
 114
 115
 116 /*
 117  * Do calibration for both of ADCs.
 118  */
 119 void adc_init (void)
 120 {
 121   RCC->APB2ENR |= (RCC_APB2ENR_ADC1EN | RCC_APB2ENR_ADC2EN);
 122   RCC->APB2RSTR = (RCC_APB2RSTR_ADC1RST | RCC_APB2RSTR_ADC2RST);
 123   RCC->APB2RSTR = 0;
 124
 125   ADC1->CR1 = 0;
 126   ADC1->CR2 = ADC_CR2_ADON;
 127   ADC1->CR2 = ADC_CR2_ADON | ADC_CR2_RSTCAL;
 128   while ((ADC1->CR2 & ADC_CR2_RSTCAL) != 0)
 129     ;
 130   ADC1->CR2 = ADC_CR2_ADON | ADC_CR2_CAL;
 131   while ((ADC1->CR2 & ADC_CR2_CAL) != 0)
 132     ;
 133   ADC1->CR2 = 0;
 134
 135   ADC2->CR1 = 0;
 136   ADC2->CR2 = ADC_CR2_ADON;
 137   ADC2->CR2 = ADC_CR2_ADON | ADC_CR2_RSTCAL;
 138   while ((ADC2->CR2 & ADC_CR2_RSTCAL) != 0)
 139     ;
 140   ADC2->CR2 = ADC_CR2_ADON | ADC_CR2_CAL;
 141   while ((ADC2->CR2 & ADC_CR2_CAL) != 0)
 142     ;
 143   ADC2->CR2 = 0;
 144   RCC->APB2ENR &= ~(RCC_APB2ENR_ADC1EN | RCC_APB2ENR_ADC2EN);
 145 }
 146
 147 extern uint8_t __process4_stack_base__, __process4_stack_size__;
 148 const uint32_t __stackaddr_adc = (uint32_t)&__process4_stack_base__;
 149 const size_t __stacksize_adc = (size_t)&__process4_stack_size__;
 150 #define PRIO_ADC 3
 151
 152 static void adc_lld_serve_rx_interrupt (uint32_t flags);
 153
 154 #define INTR_REQ_DMA1_Channel1 11
 155 static void *
 156 adc_intr_thread (void *arg)
 157 {
 158   chopstx_intr_t interrupt;
 159
 160   (void)arg;
 161   chopstx_claim_irq (&interrupt, INTR_REQ_DMA1_Channel1);
 162
 163   while (1)
 164     {
 165       uint32_t flags;
 166
 167       chopstx_intr_wait (&interrupt);
 168       flags = DMA1->ISR & STM32_DMA_ISR_MASK; /* Channel 1 interrupt cause.  */
 169       DMA1->IFCR = STM32_DMA_ISR_MASK; /* Clear interrupt of channel 1.  */
 170       adc_lld_serve_rx_interrupt (flags);
 171     }
 172
 173   return NULL;
 174 }
 175
 176 static chopstx_t adc_thd;
 177
 178 void adc_start (void)
 179 {
 180   /* Use DMA channel 1.  */
 181   RCC->AHBENR |= RCC_AHBENR_DMA1EN;
 182   DMA1_Channel1->CCR = STM32_DMA_CCR_RESET_VALUE;
 183   DMA1->IFCR = 0xffffffff;
 184
 185   RCC->APB2ENR |= (RCC_APB2ENR_ADC1EN | RCC_APB2ENR_ADC2EN);
 186
 187   ADC1->CR1 = (ADC_CR1_DUALMOD_2 | ADC_CR1_DUALMOD_1 | ADC_CR1_DUALMOD_0
 188                | ADC_CR1_SCAN);
 189   ADC1->CR2 = (ADC_CR2_TSVREFE | ADC_CR2_EXTTRIG | ADC_CR2_SWSTART
 190                | ADC_CR2_EXTSEL | ADC_CR2_DMA | ADC_CR2_CONT | ADC_CR2_ADON);
 191   ADC1->SMPR1 = NEUG_ADC_SETTING1_SMPR1;
 192   ADC1->SMPR2 = NEUG_ADC_SETTING1_SMPR2;
 193   ADC1->SQR1 = ADC_SQR1_NUM_CH(NEUG_ADC_SETTING1_NUM_CHANNELS);
 194   ADC1->SQR2 = 0;
 195   ADC1->SQR3 = NEUG_ADC_SETTING1_SQR3;
 196
 197   ADC2->CR1 = (ADC_CR1_DUALMOD_2 | ADC_CR1_DUALMOD_1 | ADC_CR1_DUALMOD_0
 198                | ADC_CR1_SCAN);
 199   ADC2->CR2 = ADC_CR2_EXTTRIG | ADC_CR2_CONT | ADC_CR2_ADON;
 200   ADC2->SMPR1 = NEUG_ADC_SETTING2_SMPR1;
 201   ADC2->SMPR2 = NEUG_ADC_SETTING2_SMPR2;
 202   ADC2->SQR1 = ADC_SQR1_NUM_CH(NEUG_ADC_SETTING2_NUM_CHANNELS);
 203   ADC2->SQR2 = 0;
 204   ADC2->SQR3 = NEUG_ADC_SETTING2_SQR3;
 205
 206 #ifdef DELIBARATELY_DO_IT_WRONG_START_STOP
 207   ADC2->CR2 = 0;
 208   ADC1->CR2 = 0;
 209 #endif
 210
 211   adc_thd = chopstx_create (PRIO_ADC, __stackaddr_adc, __stacksize_adc,
 212                             adc_intr_thread, NULL);
 213 }
 214
 215 static int adc_mode;
 216 static uint32_t *adc_ptr;
 217 static int adc_size;
 218 static uint32_t adc_buf[64];
 219
 220 static void adc_start_conversion_internal (void)
 221 {
 222 #ifdef DELIBARATELY_DO_IT_WRONG_START_STOP
 223   /* Power on */
 224   ADC2->CR2 = ADC_CR2_EXTTRIG | ADC_CR2_CONT | ADC_CR2_ADON;
 225   ADC1->CR2 = (ADC_CR2_TSVREFE | ADC_CR2_EXTTRIG | ADC_CR2_SWSTART
 226                | ADC_CR2_EXTSEL | ADC_CR2_DMA | ADC_CR2_CONT | ADC_CR2_ADON);
 227   /* Start conversion.  tSTAB is 1uS, but we don't follow the spec.  */
 228   ADC2->CR2 = ADC_CR2_EXTTRIG | ADC_CR2_CONT | ADC_CR2_ADON;
 229   ADC1->CR2 = (ADC_CR2_TSVREFE | ADC_CR2_EXTTRIG | ADC_CR2_SWSTART
 230                | ADC_CR2_EXTSEL | ADC_CR2_DMA | ADC_CR2_CONT | ADC_CR2_ADON);
 231 #else
 232   ADC2->CR2 = ADC_CR2_EXTTRIG | ADC_CR2_CONT | ADC_CR2_ADON;
 233   ADC1->CR2 = (ADC_CR2_TSVREFE | ADC_CR2_EXTTRIG | ADC_CR2_SWSTART
 234                | ADC_CR2_EXTSEL | ADC_CR2_DMA | ADC_CR2_CONT | ADC_CR2_ADON);
 235 #endif
 236 }
 237
 238 void adc_start_conversion (int mode, uint32_t *p, int size)
 239 {
 240   adc_mode = mode;
 241   adc_ptr = p;
 242   adc_size = size;
 243
 244  if (mode == ADC_SAMPLE_MODE)
 245     {
 246       DMA1_Channel1->CPAR = (uint32_t)&ADC1->DR; /* SetPeripheral */
 247       DMA1_Channel1->CMAR  = (uint32_t)p; /* SetMemory0 */
 248       DMA1_Channel1->CNDTR  = (uint32_t)size / 4; /* counter */
 249       DMA1_Channel1->CCR  = NEUG_DMA_MODE_SAMPLE; /*mode*/
 250       DMA1_Channel1->CCR |= DMA_CCR1_EN;                    /* Enable */
 251     }
 252   else
 253     {
 254       DMA1_Channel1->CPAR = (uint32_t)&ADC1->DR; /* SetPeripheral */
 255       DMA1_Channel1->CMAR  = (uint32_t)adc_buf; /* SetMemory0 */
 256       DMA1_Channel1->CNDTR  = size; /* counter */
 257       DMA1_Channel1->CCR  = NEUG_DMA_MODE_CRC32; /*mode*/
 258       DMA1_Channel1->CCR |= DMA_CCR1_EN;                    /* Enable */
 259     }
 260
 261  adc_start_conversion_internal ();
 262 }
 263
 264
 265 static void adc_stop_conversion (void)
 266 {
 267   DMA1_Channel1->CCR &= ~DMA_CCR1_EN;
 268
 269 #ifdef DELIBARATELY_DO_IT_WRONG_START_STOP
 270   ADC1->CR2 = 0;
 271   ADC2->CR2 = 0;
 272 #else
 273   ADC2->CR2 &= ~ADC_CR2_CONT;
 274   ADC1->CR2 &= ~ADC_CR2_CONT;
 275 #endif
 276 }
 277
 278 void adc_stop (void)
 279 {
 280   ADC1->CR1 = 0;
 281   ADC1->CR2 = 0;
 282
 283   ADC2->CR1 = 0;
 284   ADC2->CR2 = 0;
 285
 286   /* XXX: here to disable the associated IRQ vector; stop intr thread.  */
 287   RCC->AHBENR &= ~RCC_AHBENR_DMA1EN;
 288   RCC->APB2ENR &= ~(RCC_APB2ENR_ADC1EN | RCC_APB2ENR_ADC2EN);
 289
 290   chopstx_cancel (adc_thd);
 291   chopstx_join (adc_thd, NULL);
 292 }
 293
 294
 295 static void adc_lld_serve_rx_interrupt (uint32_t flags)
 296 {
 297   if ((flags & STM32_DMA_ISR_TEIF) != 0)  /* DMA errors  */
 298     {
 299       /* Should never happened.  If any, it's coding error. */
 300       /* Access an unmapped address space or alignment violation.  */
 301       adc_stop_conversion ();
 302     }
 303   else
 304     {
 305       if ((flags & STM32_DMA_ISR_TCIF) != 0) /* Transfer complete */
 306         {
 307           adc_stop_conversion ();
 308
 309           if (adc_mode != ADC_SAMPLE_MODE)
 310             {
 311               int i;
 312
 313               for (i = 0; i < adc_size;)
 314                 {
 315                   CRC->DR = adc_buf[i++];
 316                   CRC->DR = adc_buf[i++];
 317                   CRC->DR = adc_buf[i++];
 318                   CRC->DR = adc_buf[i++];
 319                   *adc_ptr++ = CRC->DR;
 320                 }
 321             }
 322
 323           chopstx_mutex_lock (&adc_mtx);
 324           adc_data_available++;
 325           if (adc_waiting)
 326             chopstx_cond_signal (&adc_cond);
 327           chopstx_mutex_unlock (&adc_mtx);
 328         }
 329     }
 330 }