git.gag.com Git - fw/altos/blob - src/stm/ao_i2c_stm.c

   1 /*
   2  * Copyright © 2012 Keith Packard <keithp@keithp.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  16  */
  17
  18 #include <ao.h>
  19
  20 struct ao_i2c_stm_info {
  21         uint8_t tx_dma_index;
  22         uint8_t rx_dma_index;
  23         struct stm_i2c  *stm_i2c;
  24 };
  25
  26 #define I2C_TIMEOUT     100
  27
  28 #define I2C_IDLE        0
  29 #define I2C_RUNNING     1
  30 #define I2C_ERROR       2
  31
  32 static uint8_t  ao_i2c_state[STM_NUM_I2C];
  33 static uint16_t ao_i2c_addr[STM_NUM_I2C];
  34 uint8_t         ao_i2c_mutex[STM_NUM_I2C];
  35
  36 #if AO_PCLK1 == 2000000
  37 # define AO_STM_I2C_CR2_FREQ    STM_I2C_CR2_FREQ_2_MHZ
  38 #endif
  39 #if AO_PCLK1 == 4000000
  40 #  define AO_STM_I2C_CR2_FREQ   STM_I2C_CR2_FREQ_4_MHZ
  41 #endif
  42 #if AO_PCLK1 == 8000000
  43 # define AO_STM_I2C_CR2_FREQ    STM_I2C_CR2_FREQ_8_MHZ
  44 #endif
  45 #if AO_PCLK1 == 16000000
  46 # define AO_STM_I2C_CR2_FREQ    STM_I2C_CR2_FREQ_16_MHZ
  47 #endif
  48 #if AO_PCLK1 == 32000000
  49 # define AO_STM_I2C_CR2_FREQ    STM_I2C_CR2_FREQ_32_MHZ
  50 #endif
  51
  52 #define AO_STM_I2C_CR1 ((0 << STM_I2C_CR1_SWRST) |      \
  53                         (0 << STM_I2C_CR1_ALERT) |      \
  54                         (0 << STM_I2C_CR1_PEC) |        \
  55                         (0 << STM_I2C_CR1_POS) |        \
  56                         (0 << STM_I2C_CR1_ACK) |        \
  57                         (0 << STM_I2C_CR1_STOP) |       \
  58                         (0 << STM_I2C_CR1_START) |      \
  59                         (0 << STM_I2C_CR1_NOSTRETCH) |  \
  60                         (0 << STM_I2C_CR1_ENGC) |       \
  61                         (0 << STM_I2C_CR1_ENPEC) |      \
  62                         (0 << STM_I2C_CR1_ENARP) |      \
  63                         (0 << STM_I2C_CR1_SMBTYPE) |    \
  64                         (0 << STM_I2C_CR1_SMBUS) |      \
  65                         (1 << STM_I2C_CR1_PE))
  66
  67 #define AO_STM_I2C_CR2  ((0 << STM_I2C_CR2_LAST) |                      \
  68                          (0 << STM_I2C_CR2_DMAEN) |                     \
  69                          (0 << STM_I2C_CR2_ITBUFEN) |                   \
  70                          (0 << STM_I2C_CR2_ITEVTEN) |                   \
  71                          (0 << STM_I2C_CR2_ITERREN) |                   \
  72                          (AO_STM_I2C_CR2_FREQ << STM_I2C_CR2_FREQ))
  73
  74 static const struct ao_i2c_stm_info     ao_i2c_stm_info[STM_NUM_I2C] = {
  75         {
  76                 .tx_dma_index = STM_DMA_INDEX(STM_DMA_CHANNEL_I2C1_TX),
  77                 .rx_dma_index = STM_DMA_INDEX(STM_DMA_CHANNEL_I2C1_RX),
  78                 .stm_i2c = &stm_i2c1
  79         },
  80         {
  81                 .tx_dma_index = STM_DMA_INDEX(STM_DMA_CHANNEL_I2C2_TX),
  82                 .rx_dma_index = STM_DMA_INDEX(STM_DMA_CHANNEL_I2C2_RX),
  83                 .stm_i2c = &stm_i2c2
  84         },
  85 };
  86
  87 static uint8_t  *ao_i2c_recv_data[STM_NUM_I2C];
  88 static uint16_t ao_i2c_recv_len[STM_NUM_I2C];
  89 static uint16_t ev_count;
  90
  91 static void
  92 ao_i2c_ev_isr(uint8_t index)
  93 {
  94         struct stm_i2c  *stm_i2c = ao_i2c_stm_info[index].stm_i2c;
  95         uint32_t        sr1;
  96
  97         ++ev_count;
  98         sr1 = stm_i2c->sr1;
  99         if (sr1 & (1 << STM_I2C_SR1_SB))
 100                 stm_i2c->dr = ao_i2c_addr[index];
 101         if (sr1 & (1 << STM_I2C_SR1_ADDR)) {
 102                 stm_i2c->cr2 &= ~(1 << STM_I2C_CR2_ITEVTEN);
 103                 ao_i2c_state[index] = I2C_RUNNING;
 104                 ao_wakeup(&ao_i2c_state[index]);
 105         }
 106         if (sr1 & (1 << STM_I2C_SR1_BTF)) {
 107                 stm_i2c->cr2 &= ~(1 << STM_I2C_CR2_ITEVTEN);
 108                 ao_wakeup(&ao_i2c_state[index]);
 109         }
 110         if (sr1 & (1 << STM_I2C_SR1_RXNE)) {
 111                 if (ao_i2c_recv_len[index]) {
 112                         *(ao_i2c_recv_data[index]++) = stm_i2c->dr;
 113                         if (!--ao_i2c_recv_len[index])
 114                                 ao_wakeup(&ao_i2c_recv_len[index]);
 115                 }
 116         }
 117 }
 118
 119 void stm_i2c1_ev_isr(void) { ao_i2c_ev_isr(0); }
 120 void stm_i2c2_ev_isr(void) { ao_i2c_ev_isr(1); }
 121
 122 static void
 123 ao_i2c_er_isr(uint8_t index)
 124 {
 125         struct stm_i2c  *stm_i2c = ao_i2c_stm_info[index].stm_i2c;
 126         uint32_t        sr1;
 127
 128         sr1 = stm_i2c->sr1;
 129         if (sr1 & (1 << STM_I2C_SR1_AF)) {
 130                 ao_i2c_state[index] = I2C_ERROR;
 131                 stm_i2c->sr1 = sr1 & ~(1 << STM_I2C_SR1_AF);
 132                 ao_wakeup(&ao_i2c_state[index]);
 133         }
 134 }
 135
 136 void stm_i2c1_er_isr(void) { ao_i2c_er_isr(0); }
 137 void stm_i2c2_er_isr(void) { ao_i2c_er_isr(1); }
 138
 139 void
 140 ao_i2c_get(uint8_t index)
 141 {
 142         struct stm_i2c  *stm_i2c = ao_i2c_stm_info[index].stm_i2c;
 143         ao_mutex_get(&ao_i2c_mutex[index]);
 144
 145         stm_i2c->sr1 = 0;
 146         stm_i2c->sr2 = 0;
 147 }
 148
 149 void
 150 ao_i2c_put(uint8_t index)
 151 {
 152         ao_mutex_put(&ao_i2c_mutex[index]);
 153 }
 154
 155 uint8_t
 156 ao_i2c_start(uint8_t index, uint16_t addr)
 157 {
 158         struct stm_i2c  *stm_i2c = ao_i2c_stm_info[index].stm_i2c;
 159         uint32_t        sr1, sr2;
 160         int             t;
 161
 162         ao_i2c_state[index] = I2C_IDLE;
 163         ao_i2c_addr[index] = addr;
 164         stm_i2c->cr2 = AO_STM_I2C_CR2;
 165         stm_i2c->cr1 = AO_STM_I2C_CR1 | (1 << STM_I2C_CR1_START);
 166         for (t = 0; t < I2C_TIMEOUT; t++) {
 167                 if (!(stm_i2c->cr1 & (1 << STM_I2C_CR1_START)))
 168                         break;
 169         }
 170         ao_alarm(AO_MS_TO_TICKS(250));
 171         cli();
 172         stm_i2c->cr2 = AO_STM_I2C_CR2 | (1 << STM_I2C_CR2_ITEVTEN) | (1 << STM_I2C_CR2_ITERREN);
 173         ao_i2c_ev_isr(index);
 174         while (ao_i2c_state[index] == I2C_IDLE)
 175                 if (ao_sleep(&ao_i2c_state[index]))
 176                         break;
 177         sei();
 178         ao_clear_alarm();
 179         return ao_i2c_state[index] == I2C_RUNNING;
 180 }
 181
 182 static void
 183 ao_i2c_wait_stop(uint8_t index)
 184 {
 185         struct stm_i2c  *stm_i2c = ao_i2c_stm_info[index].stm_i2c;
 186         int     t;
 187
 188         for (t = 0; t < I2C_TIMEOUT; t++) {
 189                 if (!(stm_i2c->cr1 & (1 << STM_I2C_CR1_STOP)))
 190                         break;
 191                 ao_yield();
 192         }
 193         ao_i2c_state[index] = I2C_IDLE;
 194 }
 195
 196 static void
 197 ao_i2c_wait_addr(uint8_t index)
 198 {
 199         struct stm_i2c  *stm_i2c = ao_i2c_stm_info[index].stm_i2c;
 200         int     t;
 201
 202         for (t = 0; t < I2C_TIMEOUT; t++)
 203                 if (!(stm_i2c->sr1 & (1 << STM_I2C_SR1_ADDR)))
 204                         break;
 205         if (t)
 206                 printf ("wait_addr %d\n", t);
 207 }
 208
 209 uint8_t
 210 ao_i2c_send(void *block, uint16_t len, uint8_t index, uint8_t stop)
 211 {
 212         struct stm_i2c  *stm_i2c = ao_i2c_stm_info[index].stm_i2c;
 213         uint8_t         *b = block;
 214         uint32_t        sr1;
 215         uint8_t         tx_dma_index = ao_i2c_stm_info[index].tx_dma_index;
 216         int             t;
 217
 218         /* Clear any pending ADDR bit */
 219         (void) stm_i2c->sr2;
 220         ao_i2c_wait_addr(index);
 221         stm_i2c->cr2 = AO_STM_I2C_CR2 | (1 << STM_I2C_CR2_DMAEN);
 222         ao_dma_set_transfer(tx_dma_index,
 223                             &stm_i2c->dr,
 224                             block,
 225                             len,
 226                             (0 << STM_DMA_CCR_MEM2MEM) |
 227                             (STM_DMA_CCR_PL_MEDIUM << STM_DMA_CCR_PL) |
 228                             (STM_DMA_CCR_MSIZE_8 << STM_DMA_CCR_MSIZE) |
 229                             (STM_DMA_CCR_PSIZE_8 << STM_DMA_CCR_PSIZE) |
 230                             (1 << STM_DMA_CCR_MINC) |
 231                             (0 << STM_DMA_CCR_PINC) |
 232                             (0 << STM_DMA_CCR_CIRC) |
 233                             (STM_DMA_CCR_DIR_MEM_TO_PER << STM_DMA_CCR_DIR));
 234
 235         ao_dma_start(tx_dma_index);
 236         ao_alarm(1 + len);
 237         cli();
 238         while (!ao_dma_done[tx_dma_index])
 239                 if (ao_sleep(&ao_dma_done[tx_dma_index]))
 240                         break;
 241         ao_clear_alarm();
 242         ao_dma_done_transfer(tx_dma_index);
 243         stm_i2c->cr2 = AO_STM_I2C_CR2 | (1 << STM_I2C_CR2_ITEVTEN) | (1 << STM_I2C_CR2_ITERREN);
 244         while ((stm_i2c->sr1 & (1 << STM_I2C_SR1_BTF)) == 0)
 245                 if (ao_sleep(&ao_i2c_state[index]))
 246                         break;
 247         stm_i2c->cr2 = AO_STM_I2C_CR2;
 248         sei();
 249         if (stop) {
 250                 stm_i2c->cr1 = AO_STM_I2C_CR1 | (1 << STM_I2C_CR1_STOP);
 251                 ao_i2c_wait_stop(index);
 252         }
 253         return TRUE;
 254 }
 255
 256 void
 257 ao_i2c_recv_dma_isr(int index)
 258 {
 259         int             i;
 260         struct stm_i2c  *stm_i2c = NULL;
 261
 262         for (i = 0; i < STM_NUM_I2C; i++)
 263                 if (index == ao_i2c_stm_info[i].rx_dma_index) {
 264                         stm_i2c = ao_i2c_stm_info[i].stm_i2c;
 265                         break;
 266                 }
 267         if (!stm_i2c)
 268                 return;
 269         stm_i2c->cr2 = AO_STM_I2C_CR2 | (1 << STM_I2C_CR2_LAST);
 270         ao_dma_done[index] = 1;
 271         ao_wakeup(&ao_dma_done[index]);
 272 }
 273
 274 uint8_t
 275 ao_i2c_recv(void *block, uint16_t len, uint8_t index, uint8_t stop)
 276 {
 277         struct stm_i2c  *stm_i2c = ao_i2c_stm_info[index].stm_i2c;
 278         uint8_t         *b = block;
 279         int             t;
 280         uint8_t         ret = TRUE;
 281
 282         if (len == 0)
 283                 return TRUE;
 284         if (len == 1) {
 285                 ao_i2c_recv_data[index] = block;
 286                 ao_i2c_recv_len[index] = 1;
 287                 stm_i2c->cr1 = AO_STM_I2C_CR1;
 288
 289                 /* Clear any pending ADDR bit */
 290                 stm_i2c->sr2;
 291                 ao_i2c_wait_addr(index);
 292
 293                 /* Enable interrupts to transfer the byte */
 294                 stm_i2c->cr2 = (AO_STM_I2C_CR2 |
 295                                 (1 << STM_I2C_CR2_ITEVTEN) |
 296                                 (1 << STM_I2C_CR2_ITERREN) |
 297                                 (1 << STM_I2C_CR2_ITBUFEN));
 298                 if (stop)
 299                         stm_i2c->cr1 = AO_STM_I2C_CR1 | (1 << STM_I2C_CR1_STOP);
 300
 301                 ao_alarm(1);
 302                 cli();
 303                 while (ao_i2c_recv_len[index])
 304                         if (ao_sleep(&ao_i2c_recv_len[index]))
 305                                 break;
 306                 sei();
 307                 ret = ao_i2c_recv_len[index] == 0;
 308                 ao_clear_alarm();
 309         } else {
 310                 uint8_t         rx_dma_index = ao_i2c_stm_info[index].rx_dma_index;
 311                 ao_dma_set_transfer(rx_dma_index,
 312                                     &stm_i2c->dr,
 313                                     block,
 314                                     len,
 315                                     (0 << STM_DMA_CCR_MEM2MEM) |
 316                                     (STM_DMA_CCR_PL_MEDIUM << STM_DMA_CCR_PL) |
 317                                     (STM_DMA_CCR_MSIZE_8 << STM_DMA_CCR_MSIZE) |
 318                                     (STM_DMA_CCR_PSIZE_8 << STM_DMA_CCR_PSIZE) |
 319                                     (1 << STM_DMA_CCR_MINC) |
 320                                     (0 << STM_DMA_CCR_PINC) |
 321                                     (0 << STM_DMA_CCR_CIRC) |
 322                                     (STM_DMA_CCR_DIR_PER_TO_MEM << STM_DMA_CCR_DIR));
 323                 stm_i2c->cr1 = AO_STM_I2C_CR1 | (1 << STM_I2C_CR1_ACK);
 324                 stm_i2c->cr2 = AO_STM_I2C_CR2 |
 325                         (1 << STM_I2C_CR2_DMAEN) | (1 << STM_I2C_CR2_LAST);
 326                 /* Clear any pending ADDR bit */
 327                 (void) stm_i2c->sr2;
 328                 ao_i2c_wait_addr(index);
 329
 330                 ao_dma_start(rx_dma_index);
 331                 ao_alarm(len);
 332                 cli();
 333                 while (!ao_dma_done[rx_dma_index])
 334                         if (ao_sleep(&ao_dma_done[rx_dma_index]))
 335                                 break;
 336                 sei();
 337                 ao_clear_alarm();
 338                 ret = ao_dma_done[rx_dma_index];
 339                 ao_dma_done_transfer(rx_dma_index);
 340                 stm_i2c->cr1 = AO_STM_I2C_CR1 | (1 << STM_I2C_CR1_STOP);
 341         }
 342         if (stop)
 343                 ao_i2c_wait_stop(index);
 344         return ret;
 345 }
 346
 347 void
 348 ao_i2c_channel_init(uint8_t index)
 349 {
 350         struct stm_i2c  *stm_i2c = ao_i2c_stm_info[index].stm_i2c;
 351         int i;
 352
 353         /* Turn I2C off while configuring */
 354         stm_i2c->cr1 = (1 << STM_I2C_CR1_SWRST);
 355         for (i = 0; i < 100; i++)
 356                 asm("nop");
 357         stm_i2c->cr1 = 0;
 358         stm_i2c->cr2 = AO_STM_I2C_CR2;
 359
 360         (void) stm_i2c->sr1;
 361         (void) stm_i2c->sr2;
 362         (void) stm_i2c->dr;
 363
 364         stm_i2c->sr1 = 0;
 365         stm_i2c->sr2 = 0;
 366
 367         stm_i2c->ccr = ((0 << STM_I2C_CCR_FS) |
 368                         (0 << STM_I2C_CCR_DUTY) |
 369                         (80 << STM_I2C_CCR_CCR));
 370
 371         stm_i2c->trise = 17;
 372
 373         stm_i2c->cr1 = AO_STM_I2C_CR1;
 374 }
 375
 376 void
 377 ao_i2c_init(void)
 378 {
 379         /* All of the I2C configurations are on port B */
 380         stm_rcc.ahbenr |= (1 << STM_RCC_AHBENR_GPIOBEN);
 381 #if HAS_I2C_1
 382 # if I2C_1_PB6_PB7
 383         stm_afr_set(&stm_gpiob, 6, STM_AFR_AF4);
 384         stm_afr_set(&stm_gpiob, 7, STM_AFR_AF4);
 385 # else
 386 #  if I2C_1_PB8_PB9
 387         stm_afr_set(&stm_gpiob, 8, STM_AFR_AF4);
 388         stm_afr_set(&stm_gpiob, 9, STM_AFR_AF4);
 389 #  else
 390 #   error "No I2C_1 port configuration specified"
 391 #  endif
 392 # endif
 393
 394         stm_rcc.apb1enr |= (1 << STM_RCC_APB1ENR_I2C1EN);
 395         ao_i2c_channel_init(0);
 396
 397         stm_nvic_set_enable(STM_ISR_I2C1_EV_POS);
 398         stm_nvic_set_priority(STM_ISR_I2C1_EV_POS, 3);
 399         stm_nvic_set_enable(STM_ISR_I2C1_ER_POS);
 400         stm_nvic_set_priority(STM_ISR_I2C1_ER_POS, 3);
 401 #endif
 402
 403 #if HAS_I2C_2
 404 # if I2C_2_PB10_PB11
 405         stm_afr_set(&stm_gpiob, 10, STM_AFR_AF4);
 406         stm_afr_set(&stm_gpiob, 11, STM_AFR_AF4);
 407 # else
 408 #  error "No I2C_2 port configuration specified"
 409 # endif
 410         stm_rcc.apb1enr |= (1 << STM_RCC_APB1ENR_I2C2EN);
 411         ao_i2c_channel_init(1);
 412
 413         stm_nvic_set_enable(STM_ISR_I2C2_EV_POS);
 414         stm_nvic_set_priority(STM_ISR_I2C2_EV_POS, 3);
 415         stm_nvic_set_enable(STM_ISR_I2C2_ER_POS);
 416         stm_nvic_set_priority(STM_ISR_I2C2_ER_POS, 3);
 417 #endif
 418 }