OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [Common/] [drivers/] [ST/] [STM32F10xFWLib/] [src/] [stm32f10x_i2c.c] - Blame information for rev 608

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 608 jeremybenn
/******************** (C) COPYRIGHT 2007 STMicroelectronics ********************
2
* File Name          : stm32f10x_i2c.c
3
* Author             : MCD Application Team
4
* Date First Issued  : 09/29/2006
5
* Description        : This file provides all the I2C firmware functions.
6
********************************************************************************
7
* History:
8
* 04/02/2007: V0.2
9
* 02/05/2007: V0.1
10
* 09/29/2006: V0.01
11
********************************************************************************
12
* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
13
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
14
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
15
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
16
* CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
17
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
18
*******************************************************************************/
19
 
20
/* Includes ------------------------------------------------------------------*/
21
#include "stm32f10x_i2c.h"
22
#include "stm32f10x_rcc.h"
23
 
24
/* Private typedef -----------------------------------------------------------*/
25
/* Private define ------------------------------------------------------------*/
26
/* I2C SPE mask */
27
#define CR1_PE_Set              ((u16)0x0001)
28
#define CR1_PE_Reset            ((u16)0xFFFE)
29
 
30
/* I2C DMAEN mask */
31
#define CR2_DMAEN_Set           ((u16)0x0800)
32
#define CR2_DMAEN_Reset         ((u16)0xF7FF)
33
 
34
/* I2C LAST mask */
35
#define CR2_LAST_Set            ((u16)0x1000)
36
#define CR2_LAST_Reset          ((u16)0xEFFF)
37
 
38
/* I2C START mask */
39
#define CR1_START_Set           ((u16)0x0100)
40
#define CR1_START_Reset         ((u16)0xFEFF)
41
 
42
/* I2C STOP mask */
43
#define CR1_STOP_Set            ((u16)0x0200)
44
#define CR1_STOP_Reset          ((u16)0xFDFF)
45
 
46
/* I2C ACK mask */
47
#define CR1_ACK_Set             ((u16)0x0400)
48
#define CR1_ACK_Reset           ((u16)0xFBFF)
49
 
50
/* I2C ENGC mask */
51
#define CR1_ENGC_Set            ((u16)0x0040)
52
#define CR1_ENGC_Reset          ((u16)0xFFBF)
53
 
54
/* I2C ADD0 mask */
55
#define OAR1_ADD0_Set           ((u16)0x0001)
56
#define OAR1_ADD0_Reset         ((u16)0xFFFE)
57
 
58
/* I2C SWRST mask */
59
#define CR1_SWRST_Set           ((u16)0x8000)
60
#define CR1_SWRST_Reset         ((u16)0x7FFF)
61
 
62
/* I2C PEC mask */
63
#define CR1_PEC_Set             ((u16)0x1000)
64
 
65
/* I2C ENPEC mask */
66
#define CR1_ENPEC_Set           ((u16)0x0020)
67
#define CR1_ENPEC_Reset         ((u16)0xFFDF)
68
 
69
/* I2C ENARP mask */
70
#define CR1_ENARP_Set           ((u16)0x0010)
71
#define CR1_ENARP_Reset         ((u16)0xFFEF)
72
 
73
/* I2C NOSTRETCH mask */
74
#define CR1_NOSTRETCH_Set       ((u16)0x0080)
75
#define CR1_NOSTRETCH_Reset     ((u16)0xFF7F)
76
 
77
/* I2C ENDUAL mask */
78
#define OAR2_ENDUAL_Set         ((u16)0x0001)
79
#define OAR2_ENDUAL_Reset       ((u16)0xFFFE)
80
 
81
/* I2C F/S mask */
82
#define CCR_FS_Set              ((u16)0x8000)
83
 
84
/* I2C ADD2 mask */
85
#define OAR2_ADD2_Reset         ((u16)0xFF01)
86
 
87
/* I2C FREQ mask */
88
#define CR2_FREQ_Reset          ((u16)0xFFC0)
89
 
90
/* I2C CCR mask */
91
#define CCR_CCR_Set             ((u16)0x0FFF)
92
 
93
/* I2C FLAG mask */
94
#define I2C_FLAG_Mask           ((u32)0x00FFFFFF)
95
 
96
/* I2C registers Masks */
97
#define CR1_CLEAR_Mask          ((u16)0xFBF5)
98
 
99
/* Private macro -------------------------------------------------------------*/
100
/* Private variables ---------------------------------------------------------*/
101
/* Private function prototypes -----------------------------------------------*/
102
/* Private functions ---------------------------------------------------------*/
103
 
104
/*******************************************************************************
105
* Function Name  : I2C_DeInit
106
* Description    : Deinitializes the I2Cx peripheral registers to their default
107
*                  reset values.
108
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
109
* Output         : None
110
* Return         : None
111
*******************************************************************************/
112
void I2C_DeInit(I2C_TypeDef* I2Cx)
113
{
114
  switch (*(u32*)&I2Cx)
115
  {
116
    case I2C1_BASE:
117
      /* Enable I2C1 reset state */
118
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
119
      /* Release I2C1 from reset state */
120
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, DISABLE);
121
      break;
122
 
123
    case I2C2_BASE:
124
      /* Enable I2C2 reset state */
125
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, ENABLE);
126
      /* Release I2C2 from reset state */
127
      RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, DISABLE);
128
      break;
129
 
130
    default:
131
      break;
132
  }
133
}
134
 
135
/*******************************************************************************
136
* Function Name  : I2C_Init
137
* Description    : Initializes the I2Cx according to the specified parameters
138
*                  in the I2C_InitStruct.
139
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
140
*                  - I2C_InitStruct: pointer to a I2C_InitTypeDef structure that
141
*                    contains the configuration information for the specified
142
*                    I2C peripheral.
143
* Output         : None
144
* Return         : None
145
******************************************************************************/
146
void I2C_Init(I2C_TypeDef* I2Cx, I2C_InitTypeDef* I2C_InitStruct)
147
{
148
  u16 tmpreg = 0, freqrange = 0;
149
  u16 result = 0x04;
150
  u32 pclk1clock = 12000000;
151
  RCC_ClocksTypeDef  RCC_Clocks;
152
 
153
  /* Check the parameters */
154
  assert(IS_I2C_MODE(I2C_InitStruct->I2C_Mode));
155
  assert(IS_I2C_DUTY_CYCLE(I2C_InitStruct->I2C_DutyCycle));
156
  assert(IS_I2C_OWN_ADDRESS1(I2C_InitStruct->I2C_OwnAddress1));
157
  assert(IS_I2C_ACK_STATE(I2C_InitStruct->I2C_Ack));
158
  assert(IS_I2C_ACKNOWLEDGE_ADDRESS(I2C_InitStruct->I2C_AcknowledgedAddress));
159
  assert(IS_I2C_CLOCK_SPEED(I2C_InitStruct->I2C_ClockSpeed));
160
 
161
/*---------------------------- I2Cx CR2 Configuration ------------------------*/
162
  /* Get the I2Cx CR2 value */
163
  tmpreg = I2Cx->CR2;
164
  /* Clear frequency FREQ[5:0] bits */
165
  tmpreg &= CR2_FREQ_Reset;
166
  /* Get PCLK1Clock frequency value */
167
  RCC_GetClocksFreq(&RCC_Clocks);
168
  pclk1clock = RCC_Clocks.PCLK1_Frequency;
169
  /* Set frequency bits depending on PCLK1Clock value */
170
  freqrange = (u16)(pclk1clock / 1000000);
171
  tmpreg |= freqrange;
172
  /* Write to I2Cx CR2 */
173
  I2Cx->CR2 = tmpreg;
174
 
175
/*---------------------------- I2Cx CCR Configuration ------------------------*/
176
  /* Disable I2Cx to configure TRISE */
177
  I2C_Cmd(I2Cx, DISABLE);
178
 
179
  /* Reset tmpreg value */
180
  /* Clear F/S, DUTY and CCR[11:0] bits */
181
  tmpreg = 0;
182
 
183
  /* Configure speed in standard mode */
184
  if (I2C_InitStruct->I2C_ClockSpeed <= 100000)
185
  {
186
    /* Standard mode speed calculate */
187
    result = (u16)(pclk1clock / (I2C_InitStruct->I2C_ClockSpeed << 1));
188
    /* Test if CCR value is under 0x4*/
189
    if (result < 0x04)
190
    {
191
      /* Set minimum allowed value */
192
      result = 0x04;
193
    }
194
    /* Set speed value for standard mode */
195
    tmpreg |= result;
196
    /* Set Maximum Rise Time: ((1000/(1000000000/pclk1clock))+1 */
197
    I2Cx->TRISE = freqrange + 1;
198
  }
199
  /* Configure speed in fast mode */
200
  else /*(I2C_InitStruct->I2C_ClockSpeed <= 400000)*/
201
  {
202
    if (I2C_InitStruct->I2C_DutyCycle == I2C_DutyCycle_2)
203
    {
204
      /* Fast mode speed calculate: Tlow/Thigh = 2 */
205
      result = (u16)(pclk1clock / (I2C_InitStruct->I2C_ClockSpeed * 3));
206
    }
207
    else /*I2C_InitStruct->I2C_DutyCycle == I2C_DutyCycle_16_9*/
208
    {
209
      /* Fast mode speed calculate: Tlow/Thigh = 16/9 */
210
      result = (u16)(pclk1clock / (I2C_InitStruct->I2C_ClockSpeed * 25));
211
      /* Set DUTY bit */
212
      result |= I2C_DutyCycle_16_9;
213
    }
214
    /* Test if CCR value is under 0x1*/
215
    if ((result & CCR_CCR_Set) == 0)
216
    {
217
      /* Set minimum allowed value */
218
      result |= (u16)0x0001;
219
    }
220
    /* Set speed value and set F/S bit for fast mode */
221
    tmpreg |= result | CCR_FS_Set;
222
    /* Set Maximum Rise Time: ((300/(1000000000/pclk1clock))+1 */
223
    I2Cx->TRISE = (u16)(((freqrange * 300) / 1000) + 1);
224
  }
225
  /* Write to I2Cx CCR */
226
  I2Cx->CCR = tmpreg;
227
 
228
  /* Enable I2Cx */
229
  I2C_Cmd(I2Cx, ENABLE);
230
 
231
/*---------------------------- I2Cx CR1 Configuration ------------------------*/
232
  /* Get the I2Cx CR1 value */
233
  tmpreg = I2Cx->CR1;
234
  /* Clear ACK, SMBTYPE and  SMBUS bits */
235
  tmpreg &= CR1_CLEAR_Mask;
236
  /* Configure I2Cx: mode and acknowledgement */
237
  /* Set SMBTYPE and SMBUS bits according to I2C_Mode value */
238
  /* Set ACK bit according to I2C_Ack value */
239
  tmpreg |= (u16)((u32)I2C_InitStruct->I2C_Mode | I2C_InitStruct->I2C_Ack);
240
  /* Write to I2Cx CR1 */
241
  I2Cx->CR1 = tmpreg;
242
 
243
/*---------------------------- I2Cx OAR1 Configuration -----------------------*/
244
  /* Set I2Cx Own Address1 and acknowledged address */
245
  I2Cx->OAR1 = (I2C_InitStruct->I2C_AcknowledgedAddress | I2C_InitStruct->I2C_OwnAddress1);
246
}
247
 
248
/*******************************************************************************
249
* Function Name  : I2C_StructInit
250
* Description    : Fills each I2C_InitStruct member with its default value.
251
* Input          : - I2C_InitStruct: pointer to a I2C_InitTypeDef structure
252
*                    which will be initialized.
253
* Output         : None
254
* Return         : None
255
*******************************************************************************/
256
void I2C_StructInit(I2C_InitTypeDef* I2C_InitStruct)
257
{
258
/*---------------- Reset I2C init structure parameters values ----------------*/
259
  /* Initialize the I2C_Mode member */
260
  I2C_InitStruct->I2C_Mode = I2C_Mode_I2C;
261
 
262
  /* Initialize the I2C_DutyCycle member */
263
  I2C_InitStruct->I2C_DutyCycle = I2C_DutyCycle_2;
264
 
265
  /* Initialize the I2C_OwnAddress1 member */
266
  I2C_InitStruct->I2C_OwnAddress1 = 0;
267
 
268
  /* Initialize the I2C_Ack member */
269
  I2C_InitStruct->I2C_Ack = I2C_Ack_Disable;
270
 
271
  /* Initialize the I2C_AcknowledgedAddress member */
272
  I2C_InitStruct->I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
273
 
274
  /* initialize the I2C_ClockSpeed member */
275
  I2C_InitStruct->I2C_ClockSpeed = 5000;
276
}
277
 
278
/*******************************************************************************
279
* Function Name  : I2C_Cmd
280
* Description    : Enables or disables the specified I2C peripheral.
281
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
282
*                  - NewState: new state of the I2Cx peripheral. This parameter
283
*                    can be: ENABLE or DISABLE.
284
* Output         : None
285
* Return         : None
286
*******************************************************************************/
287
void I2C_Cmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
288
{
289
  /* Check the parameters */
290
  assert(IS_FUNCTIONAL_STATE(NewState));
291
 
292
  if (NewState != DISABLE)
293
  {
294
    /* Enable the selected I2C peripheral */
295
    I2Cx->CR1 |= CR1_PE_Set;
296
  }
297
  else
298
  {
299
    /* Disable the selected I2C peripheral */
300
    I2Cx->CR1 &= CR1_PE_Reset;
301
  }
302
}
303
 
304
/*******************************************************************************
305
* Function Name  : I2C_DMACmd
306
* Description    : Enables or disables the specified I2C DMA requests.
307
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
308
*                  - NewState: new state of the I2C DMA transfer.
309
*                    This parameter can be: ENABLE or DISABLE.
310
* Output         : None
311
* Return         : None
312
*******************************************************************************/
313
void I2C_DMACmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
314
{
315
  /* Check the parameters */
316
  assert(IS_FUNCTIONAL_STATE(NewState));
317
 
318
  if (NewState != DISABLE)
319
  {
320
    /* Enable the selected I2C DMA requests */
321
    I2Cx->CR2 |= CR2_DMAEN_Set;
322
  }
323
  else
324
  {
325
    /* Disable the selected I2C DMA requests */
326
    I2Cx->CR2 &= CR2_DMAEN_Reset;
327
  }
328
}
329
 
330
/*******************************************************************************
331
* Function Name  : I2C_DMALastTransferCmd
332
* Description    : Specifies that the next DMA transfer is the last one.
333
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
334
*                  - NewState: new state of the I2C DMA last transfer.
335
*                    This parameter can be: ENABLE or DISABLE.
336
* Output         : None
337
* Return         : None
338
*******************************************************************************/
339
void I2C_DMALastTransferCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
340
{
341
  /* Check the parameters */
342
  assert(IS_FUNCTIONAL_STATE(NewState));
343
 
344
  if (NewState != DISABLE)
345
  {
346
    /* Next DMA end of transfer is the last transfer */
347
    I2Cx->CR2 |= CR2_LAST_Set;
348
  }
349
  else
350
  {
351
    /* Next DMA end of transfer is not the last transfer */
352
    I2Cx->CR2 &= CR2_LAST_Reset;
353
  }
354
}
355
 
356
/*******************************************************************************
357
* Function Name  : I2C_GenerateSTART
358
* Description    : Generates I2Cx communication START condition.
359
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
360
*                  - NewState: new state of the I2C START condition generation.
361
*                    This parameter can be: ENABLE or DISABLE.
362
* Output         : None
363
* Return         : None.
364
*******************************************************************************/
365
void I2C_GenerateSTART(I2C_TypeDef* I2Cx, FunctionalState NewState)
366
{
367
  /* Check the parameters */
368
  assert(IS_FUNCTIONAL_STATE(NewState));
369
 
370
  if (NewState != DISABLE)
371
  {
372
    /* Generate a START condition */
373
    I2Cx->CR1 |= CR1_START_Set;
374
  }
375
  else
376
  {
377
    /* Disable the START condition generation */
378
    I2Cx->CR1 &= CR1_START_Reset;
379
  }
380
}
381
 
382
/*******************************************************************************
383
* Function Name  : I2C_GenerateSTOP
384
* Description    : Generates I2Cx communication STOP condition.
385
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
386
*                  - NewState: new state of the I2C STOP condition generation.
387
*                    This parameter can be: ENABLE or DISABLE.
388
* Output         : None
389
* Return         : None.
390
*******************************************************************************/
391
void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState)
392
{
393
  /* Check the parameters */
394
  assert(IS_FUNCTIONAL_STATE(NewState));
395
 
396
  if (NewState != DISABLE)
397
  {
398
    /* Generate a STOP condition */
399
    I2Cx->CR1 |= CR1_STOP_Set;
400
  }
401
  else
402
  {
403
    /* Disable the STOP condition generation */
404
    I2Cx->CR1 &= CR1_STOP_Reset;
405
  }
406
}
407
 
408
/*******************************************************************************
409
* Function Name  : I2C_AcknowledgeConfig
410
* Description    : Enables or disables the specified I2C acknowledge feature.
411
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
412
*                  - NewState: new state of the I2C Acknowledgement.
413
*                    This parameter can be: ENABLE or DISABLE.
414
* Output         : None
415
* Return         : None.
416
*******************************************************************************/
417
void I2C_AcknowledgeConfig(I2C_TypeDef* I2Cx, FunctionalState NewState)
418
{
419
  /* Check the parameters */
420
  assert(IS_FUNCTIONAL_STATE(NewState));
421
 
422
  if (NewState != DISABLE)
423
  {
424
    /* Enable the acknowledgement */
425
    I2Cx->CR1 |= CR1_ACK_Set;
426
  }
427
  else
428
  {
429
    /* Disable the acknowledgement */
430
    I2Cx->CR1 &= CR1_ACK_Reset;
431
  }
432
}
433
 
434
/*******************************************************************************
435
* Function Name  : I2C_OwnAddress2Config
436
* Description    : Configures the specified I2C own address2.
437
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
438
*                  - Address: specifies the 7bit I2C own address2.
439
* Output         : None
440
* Return         : None.
441
*******************************************************************************/
442
void I2C_OwnAddress2Config(I2C_TypeDef* I2Cx, u8 Address)
443
{
444
  u16 tmpreg = 0;
445
 
446
  /* Get the old register value */
447
  tmpreg = I2Cx->OAR2;
448
  /* Reset I2Cx Own address2 bit [7:1] */
449
  tmpreg &= OAR2_ADD2_Reset;
450
  /* Set I2Cx Own address2 */
451
  tmpreg |= (u16)(Address & (u16)0x00FE);
452
  /* Store the new register value */
453
  I2Cx->OAR2 = tmpreg;
454
}
455
 
456
/*******************************************************************************
457
* Function Name  : I2C_DualAddressCmd
458
* Description    : Enables or disables the specified I2C dual addressing mode.
459
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
460
*                  - NewState: new state of the I2C dual addressing mode.
461
*                    This parameter can be: ENABLE or DISABLE.
462
* Output         : None
463
* Return         : None
464
*******************************************************************************/
465
void I2C_DualAddressCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
466
{
467
  /* Check the parameters */
468
  assert(IS_FUNCTIONAL_STATE(NewState));
469
 
470
  if (NewState != DISABLE)
471
  {
472
    /* Enable dual addressing mode */
473
    I2Cx->OAR2 |= OAR2_ENDUAL_Set;
474
  }
475
  else
476
  {
477
    /* Disable dual addressing mode */
478
    I2Cx->OAR2 &= OAR2_ENDUAL_Reset;
479
  }
480
}
481
 
482
/*******************************************************************************
483
* Function Name  : I2C_GeneralCallCmd
484
* Description    : Enables or disables the specified I2C general call feature.
485
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
486
*                  - NewState: new state of the I2C General call.
487
*                    This parameter can be: ENABLE or DISABLE.
488
* Output         : None
489
* Return         : None
490
*******************************************************************************/
491
void I2C_GeneralCallCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
492
{
493
  /* Check the parameters */
494
  assert(IS_FUNCTIONAL_STATE(NewState));
495
 
496
  if (NewState != DISABLE)
497
  {
498
    /* Enable generall call */
499
    I2Cx->CR1 |= CR1_ENGC_Set;
500
  }
501
  else
502
  {
503
    /* Disable generall call */
504
    I2Cx->CR1 &= CR1_ENGC_Reset;
505
  }
506
}
507
 
508
/*******************************************************************************
509
* Function Name  : I2C_ITConfig
510
* Description    : Enables or disables the specified I2C interrupts.
511
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
512
*                  - I2C_IT: specifies the I2C interrupts sources to be enabled
513
*                    or disabled.
514
*                    This parameter can be any combination of the following values:
515
*                       - I2C_IT_BUF: Buffer interrupt mask
516
*                       - I2C_IT_EVT: Event interrupt mask
517
*                       - I2C_IT_ERR: Error interrupt mask
518
*                  - NewState: new state of the specified I2C interrupts.
519
*                    This parameter can be: ENABLE or DISABLE.
520
* Output         : None
521
* Return         : None
522
*******************************************************************************/
523
void I2C_ITConfig(I2C_TypeDef* I2Cx, u16 I2C_IT, FunctionalState NewState)
524
{
525
  /* Check the parameters */
526
  assert(IS_FUNCTIONAL_STATE(NewState));
527
  assert(IS_I2C_CONFIG_IT(I2C_IT));
528
 
529
  if (NewState != DISABLE)
530
  {
531
    /* Enable the selected I2C interrupts */
532
    I2Cx->CR2 |= I2C_IT;
533
  }
534
  else
535
  {
536
    /* Disable the selected I2C interrupts */
537
    I2Cx->CR2 &= (u16)~I2C_IT;
538
  }
539
}
540
 
541
/*******************************************************************************
542
* Function Name  : I2C_SendData
543
* Description    : Sends a data byte through the I2Cx peripheral.
544
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
545
*                  - Data: Byte to be transmitted..
546
* Output         : None
547
* Return         : None
548
*******************************************************************************/
549
void I2C_SendData(I2C_TypeDef* I2Cx, u8 Data)
550
{
551
  /* Write in the DR register the data to be sent */
552
  I2Cx->DR = Data;
553
}
554
 
555
/*******************************************************************************
556
* Function Name  : I2C_ReceiveData
557
* Description    : Returns the most recent received data by the I2Cx peripheral.
558
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
559
* Output         : None
560
* Return         : The value of the received data.
561
*******************************************************************************/
562
u8 I2C_ReceiveData(I2C_TypeDef* I2Cx)
563
{
564
  /* Return the data in the DR register */
565
  return (u8)I2Cx->DR;
566
}
567
 
568
/*******************************************************************************
569
* Function Name  : I2C_Send7bitAddress
570
* Description    : Transmits the address byte to select the slave device.
571
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
572
*                  - Address: specifies the slave address which will be transmitted
573
*                  - Direction: specifies whether the I2C device will be a
574
*                    Transmitter or a Receiver.
575
*                    This parameter can be one of the following values
576
*                       - I2C_Direction_Transmitter: Transmitter mode
577
*                       - I2C_Direction_Receiver: Receiver mode
578
* Output         : None
579
* Return         : None.
580
*******************************************************************************/
581
void I2C_Send7bitAddress(I2C_TypeDef* I2Cx, u8 Address, u8 I2C_Direction)
582
{
583
  /* Check the parameters */
584
  assert(IS_I2C_DIRECTION(I2C_Direction));
585
 
586
  /* Test on the direction to set/reset the read/write bit */
587
  if (I2C_Direction != I2C_Direction_Transmitter)
588
  {
589
    /* Set the address ADD0 bit0 for read */
590
    Address |= OAR1_ADD0_Set;
591
  }
592
  else
593
  {
594
    /* Reset the address bit0 for write */
595
    Address &= OAR1_ADD0_Reset;
596
  }
597
  /* Send the address */
598
  I2Cx->DR = Address;
599
}
600
 
601
/*******************************************************************************
602
* Function Name  : I2C_ReadRegister
603
* Description    : Reads the specified I2C register and returns its value.
604
* Input1         : - I2C_Register: specifies the register to read.
605
*                    This parameter can be one of the following values:
606
*                       - I2C_Register_CR1:  CR1 register.
607
*                       - I2C_Register_CR2:   CR2 register.
608
*                       - I2C_Register_OAR1:  OAR1 register.
609
*                       - I2C_Register_OAR2:  OAR2 register.
610
*                       - I2C_Register_DR:    DR register.
611
*                       - I2C_Register_SR1:   SR1 register.
612
*                       - I2C_Register_SR2:   SR2 register.
613
*                       - I2C_Register_CCR:   CCR register.
614
*                       - I2C_Register_TRISE: TRISE register.
615
* Output         : None
616
* Return         : The value of the read register.
617
*******************************************************************************/
618
u16 I2C_ReadRegister(I2C_TypeDef* I2Cx, u8 I2C_Register)
619
{
620
  /* Check the parameters */
621
  assert(IS_I2C_REGISTER(I2C_Register));
622
 
623
  /* Return the selected register value */
624
  return (*(u16 *)(*((u32 *)&I2Cx) + I2C_Register));
625
}
626
 
627
/*******************************************************************************
628
* Function Name  : I2C_SoftwareResetCmd
629
* Description    : Enables or disables the specified I2C software reset.
630
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
631
*                  - NewState: new state of the I2C software reset.
632
*                    This parameter can be: ENABLE or DISABLE.
633
* Output         : None
634
* Return         : None
635
*******************************************************************************/
636
void I2C_SoftwareResetCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
637
{
638
  /* Check the parameters */
639
  assert(IS_FUNCTIONAL_STATE(NewState));
640
 
641
  if (NewState != DISABLE)
642
  {
643
    /* Peripheral under reset */
644
    I2Cx->CR1 |= CR1_SWRST_Set;
645
  }
646
  else
647
  {
648
    /* Peripheral not under reset */
649
    I2Cx->CR1 &= CR1_SWRST_Reset;
650
  }
651
}
652
 
653
/*******************************************************************************
654
* Function Name  : I2C_SMBusAlertConfig
655
* Description    : Drives the SMBusAlert pin high or low for the specified I2C.
656
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
657
*                  - I2C_SMBusAlert: specifies SMBAlert pin level.
658
*                    This parameter can be one of the following values:
659
*                       - I2C_SMBusAlert_Low: SMBAlert pin driven low
660
*                       - I2C_SMBusAlert_High: SMBAlert pin driven high
661
* Output         : None
662
* Return         : None
663
*******************************************************************************/
664
void I2C_SMBusAlertConfig(I2C_TypeDef* I2Cx, u16 I2C_SMBusAlert)
665
{
666
  /* Check the parameters */
667
  assert(IS_I2C_SMBUS_ALERT(I2C_SMBusAlert));
668
 
669
  if (I2C_SMBusAlert == I2C_SMBusAlert_Low)
670
  {
671
    /* Drive the SMBusAlert pin Low */
672
    I2Cx->CR1 |= I2C_SMBusAlert_Low;
673
  }
674
  else
675
  {
676
    /* Drive the SMBusAlert pin High  */
677
    I2Cx->CR1 &= I2C_SMBusAlert_High;
678
  }
679
}
680
 
681
/*******************************************************************************
682
* Function Name  : I2C_TransmitPEC
683
* Description    : Enables the specified I2C PEC transfer.
684
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
685
* Output         : None
686
* Return         : None
687
*******************************************************************************/
688
void I2C_TransmitPEC(I2C_TypeDef* I2Cx)
689
{
690
  /* Enable the selected I2C PEC transmission */
691
  I2Cx->CR1 |= CR1_PEC_Set;
692
}
693
 
694
/*******************************************************************************
695
* Function Name  : I2C_PECPositionConfig
696
* Description    : Selects the specified I2C PEC position.
697
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
698
*                  - I2C_PECPosition: specifies the PEC position.
699
*                    This parameter can be one of the following values:
700
*                       - I2C_PECPosition_Next: PEC bit indicates that current
701
*                         byte is PEC
702
*                       - I2C_PECPosition_Current: PEC bit indicates that the
703
*                         next byte is PEC
704
* Output         : None
705
* Return         : None
706
*******************************************************************************/
707
void I2C_PECPositionConfig(I2C_TypeDef* I2Cx, u16 I2C_PECPosition)
708
{
709
  /* Check the parameters */
710
  assert(IS_I2C_PEC_POSITION(I2C_PECPosition));
711
 
712
  if (I2C_PECPosition == I2C_PECPosition_Next)
713
  {
714
    /* PEC indicates that the next byte in shift register is PEC */
715
    I2Cx->CR1 |= I2C_PECPosition_Next;
716
  }
717
  else
718
  {
719
    /* PEC indicates that the current byte in shift register is PEC */
720
    I2Cx->CR1 &= I2C_PECPosition_Current;
721
  }
722
}
723
 
724
/*******************************************************************************
725
* Function Name  : I2C_CalculatePEC
726
* Description    : Enables or disables the PEC value calculation of the
727
*                  transfered bytes.
728
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
729
*                  - NewState: new state of the I2Cx PEC value calculation.
730
*                    This parameter can be: ENABLE or DISABLE.
731
* Output         : None
732
* Return         : None
733
*******************************************************************************/
734
void I2C_CalculatePEC(I2C_TypeDef* I2Cx, FunctionalState NewState)
735
{
736
  /* Check the parameters */
737
  assert(IS_FUNCTIONAL_STATE(NewState));
738
 
739
  if (NewState != DISABLE)
740
  {
741
    /* Enable the selected I2C PEC calculation */
742
    I2Cx->CR1 |= CR1_ENPEC_Set;
743
  }
744
  else
745
  {
746
    /* Disable the selected I2C PEC calculation */
747
    I2Cx->CR1 &= CR1_ENPEC_Reset;
748
  }
749
}
750
 
751
/*******************************************************************************
752
* Function Name  : I2C_GetPEC
753
* Description    : Returns the PEC value for the specified I2C.
754
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
755
* Output         : None
756
* Return         : The PEC value.
757
*******************************************************************************/
758
u8 I2C_GetPEC(I2C_TypeDef* I2Cx)
759
{
760
  u8 pec;
761
 
762
  /* Get the PEC value */
763
  pec = (I2Cx->SR2) >> 8;
764
  /* Return the selected I2C PEC register value */
765
  return pec;
766
}
767
 
768
/*******************************************************************************
769
* Function Name  : I2C_ARPCmd
770
* Description    : Enables or disables the specified I2C ARP.
771
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
772
*                  - NewState: new state of the I2Cx ARP.
773
*                    This parameter can be: ENABLE or DISABLE.
774
* Output         : None
775
* Return         : None
776
*******************************************************************************/
777
void I2C_ARPCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
778
{
779
  /* Check the parameters */
780
  assert(IS_FUNCTIONAL_STATE(NewState));
781
 
782
  if (NewState != DISABLE)
783
  {
784
    /* Enable the selected I2C ARP */
785
    I2Cx->CR1 |= CR1_ENARP_Set;
786
  }
787
  else
788
  {
789
    /* Disable the selected I2C ARP */
790
    I2Cx->CR1 &= CR1_ENARP_Reset;
791
  }
792
}
793
 
794
/*******************************************************************************
795
* Function Name  : I2C_StretchClockCmd
796
* Description    : Enables or disables the specified I2C Clock stretching.
797
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
798
*                  - NewState: new state of the I2Cx Clock stretching.
799
*                    This parameter can be: ENABLE or DISABLE.
800
* Output         : None
801
* Return         : None
802
*******************************************************************************/
803
void I2C_StretchClockCmd(I2C_TypeDef* I2Cx, FunctionalState NewState)
804
{
805
  /* Check the parameters */
806
  assert(IS_FUNCTIONAL_STATE(NewState));
807
 
808
  if (NewState == DISABLE)
809
  {
810
    /* Enable the selected I2C Clock stretching */
811
    I2Cx->CR1 |= CR1_NOSTRETCH_Set;
812
  }
813
  else
814
  {
815
    /* Disable the selected I2C Clock stretching */
816
    I2Cx->CR1 &= CR1_NOSTRETCH_Reset;
817
  }
818
}
819
 
820
/*******************************************************************************
821
* Function Name  : I2C_FastModeDutyCycleConfig
822
* Description    : Selects the specified I2C fast mode duty cycle.
823
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
824
*                  - I2C_DutyCycle: specifies the fast mode duty cycle.
825
*                    This parameter can be one of the following values:
826
*                       - I2C_DutyCycle_2: I2C fast mode Tlow/Thigh = 2
827
*                       - I2C_DutyCycle_16_9: I2C fast mode Tlow/Thigh = 16/9
828
* Output         : None
829
* Return         : None
830
*******************************************************************************/
831
void I2C_FastModeDutyCycleConfig(I2C_TypeDef* I2Cx, u16 I2C_DutyCycle)
832
{
833
  /* Check the parameters */
834
  assert(IS_I2C_DUTY_CYCLE(I2C_DutyCycle));
835
 
836
  if (I2C_DutyCycle != I2C_DutyCycle_16_9)
837
  {
838
    /* I2C fast mode Tlow/Thigh=2 */
839
    I2Cx->CCR &= I2C_DutyCycle_2;
840
  }
841
  else
842
  {
843
    /* I2C fast mode Tlow/Thigh=16/9 */
844
    I2Cx->CCR |= I2C_DutyCycle_16_9;
845
  }
846
}
847
 
848
/*******************************************************************************
849
* Function Name  : I2C_GetLastEvent
850
* Description    : Returns the Last I2C Event.
851
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
852
* Output         : None
853
* Return         : The last event
854
*******************************************************************************/
855
u32 I2C_GetLastEvent(I2C_TypeDef* I2Cx)
856
{
857
  u32 LastEvent = 0;
858
  u32 Flag1 = 0, Flag2 = 0;
859
 
860
  Flag1 = I2Cx->SR1;
861
  Flag2 = I2Cx->SR2;
862
  Flag2 = Flag2 << 16;
863
 
864
  /* Get the last event value from I2C status register */
865
  LastEvent = (Flag1 | Flag2) & I2C_FLAG_Mask;
866
 
867
  /* Return status */
868
  return LastEvent;
869
}
870
 
871
/*******************************************************************************
872
* Function Name  : I2C_CheckEvent
873
* Description    : Checks whether the Last I2C Event is equal to the one passed
874
*                  as parameter.
875
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
876
*                  - I2C_EVENT: specifies the event to be checked.
877
*                    This parameter can be one of the following values:
878
*                       - I2C_EVENT_SLAVE_ADDRESS_MATCHED   : EV1
879
*                       - I2C_EVENT_SLAVE_BYTE_RECEIVED     : EV2
880
*                       - I2C_EVENT_SLAVE_BYTE_TRANSMITTED  : EV3
881
*                       - I2C_EVENT_SLAVE_ACK_FAILURE       : EV3-1
882
*                       - I2C_EVENT_MASTER_MODE_SELECT      : EV5
883
*                       - I2C_EVENT_MASTER_MODE_SELECTED    : EV6
884
*                       - I2C_EVENT_MASTER_BYTE_RECEIVED    : EV7
885
*                       - I2C_EVENT_MASTER_BYTE_TRANSMITTED : EV8
886
*                       - I2C_EVENT_MASTER_MODE_ADDRESS10   : EV9
887
*                       - I2C_EVENT_SLAVE_STOP_DETECTED     : EV4
888
* Output         : None
889
* Return         : An ErrorStatus enumuration value:
890
*                       - SUCCESS: Last event is equal to the I2C_Event
891
*                       - ERROR: Last event is different from the I2C_Event
892
*******************************************************************************/
893
ErrorStatus I2C_CheckEvent(I2C_TypeDef* I2Cx, u32 I2C_EVENT)
894
{
895
  u32 LastEvent = 0;
896
  u32 Flag1 = 0, Flag2 = 0;
897
  ErrorStatus status = ERROR;
898
 
899
  /* Check the parameters */
900
  assert(IS_I2C_EVENT(I2C_EVENT));
901
 
902
  Flag1 = I2Cx->SR1;
903
  Flag2 = I2Cx->SR2;
904
  Flag2 = Flag2 << 16;
905
 
906
  /* Get the last event value from I2C status register */
907
  LastEvent = (Flag1 | Flag2) & I2C_FLAG_Mask;
908
 
909
  /* Check whether the last event is equal to I2C_EVENT */
910
  if (LastEvent == I2C_EVENT )
911
  {
912
    /* SUCCESS: last event is equal to I2C_EVENT */
913
    status = SUCCESS;
914
  }
915
  else
916
  {
917
    /* ERROR: last event is different from I2C_EVENT */
918
    status = ERROR;
919
  }
920
 
921
  /* Return status */
922
  return status;
923
}
924
 
925
/*******************************************************************************
926
* Function Name  : I2C_GetFlagStatus
927
* Description    : Checks whether the specified I2C flag is set or not.
928
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
929
*                  - I2C_FLAG: specifies the flag to check.
930
*                    This parameter can be one of the following values:
931
*                       - I2C_FLAG_DUALF: Dual flag (Slave mode)
932
*                       - I2C_FLAG_SMBHOST: SMBus host header (Slave mode)
933
*                       - I2C_FLAG_SMBDEFAULT: SMBus default header (Slave mode)
934
*                       - I2C_FLAG_GENCALL: General call header flag (Slave mode)
935
*                       - I2C_FLAG_TRA: Transmitter/Receiver flag
936
*                       - I2C_FLAG_BUSY: Bus busy flag
937
*                       - I2C_FLAG_MSL: Master/Slave flag
938
*                       - I2C_FLAG_SMBALERT: SMBus Alert flag
939
*                       - I2C_FLAG_TIMEOUT: Timeout or Tlow error flag
940
*                       - I2C_FLAG_PECERR: PEC error in reception flag
941
*                       - I2C_FLAG_OVR: Overrun/Underrun flag (Slave mode)
942
*                       - I2C_FLAG_AF: Acknowledge failure flag
943
*                       - I2C_FLAG_ARLO: Arbitration lost flag (Master mode)
944
*                       - I2C_FLAG_BERR: Bus error flag
945
*                       - I2C_FLAG_TXE: Data register empty flag (Transmitter)
946
*                       - I2C_FLAG_RXNE: Data register not empty (Receiver) flag
947
*                       - I2C_FLAG_STOPF: Stop detection flag (Slave mode)
948
*                       - I2C_FLAG_ADD10: 10-bit header sent flag (Master mode)
949
*                       - I2C_FLAG_BTF: Byte transfer finished flag
950
*                       - I2C_FLAG_ADDR: Address sent flag (Master mode) “ADSL”
951
*                                        Address matched flag (Slave mode)”ENDAD”
952
*                       - I2C_FLAG_SB: Start bit flag (Master mode)
953
* Output         : None
954
* Return         : The new state of I2C_FLAG (SET or RESET).
955
*******************************************************************************/
956
FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, u32 I2C_FLAG)
957
{
958
  FlagStatus bitstatus = RESET;
959
  u32 i2cstatus = 0;
960
  u32 Flag1 = 0, Flag2 = 0;
961
 
962
  /* Check the parameters */
963
  assert(IS_I2C_GET_FLAG(I2C_FLAG));
964
 
965
  /* Read the I2Cx status register */
966
  Flag1 = I2Cx->SR1;
967
  Flag2 = I2Cx->SR2;
968
  Flag2 = (Flag2 & I2C_FLAG_Mask) << 16;
969
 
970
  /* Get the I2C status value */
971
  i2cstatus = Flag1 | Flag2;
972
 
973
  /* Get bit[27:0] of the flag */
974
  I2C_FLAG &= I2C_FLAG_Mask;
975
 
976
  /* Check the status of the specified I2C flag */
977
  if ((i2cstatus & I2C_FLAG) != (u32)RESET)
978
  {
979
    /* I2C_FLAG is set */
980
    bitstatus = SET;
981
  }
982
  else
983
  {
984
    /* I2C_FLAG is reset */
985
    bitstatus = RESET;
986
  }
987
  /* Return the I2C_FLAG status */
988
  return  bitstatus;
989
}
990
 
991
/*******************************************************************************
992
* Function Name  : I2C_ClearFlag
993
* Description    : Clears the I2Cx's pending flags.
994
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
995
*                  - I2C_FLAG: specifies the flag to clear.
996
*                    This parameter can be one of the following values:
997
*                       - I2C_FLAG_SMBALERT: SMBus Alert flag
998
*                       - I2C_FLAG_TIMEOUT: Timeout or Tlow error flag
999
*                       - I2C_FLAG_PECERR: PEC error in reception flag
1000
*                       - I2C_FLAG_OVR: Overrun/Underrun flag (Slave mode)
1001
*                       - I2C_FLAG_AF: Acknowledge failure flag
1002
*                       - I2C_FLAG_ARLO: Arbitration lost flag (Master mode)
1003
*                       - I2C_FLAG_BERR: Bus error flag
1004
*                       - I2C_FLAG_STOPF: Stop detection flag (Slave mode)
1005
*                       - I2C_FLAG_ADD10: 10-bit header sent flag (Master mode)
1006
*                       - I2C_FLAG_BTF: Byte transfer finished flag
1007
*                       - I2C_FLAG_ADDR: Address sent flag (Master mode) “ADSL”
1008
*                                        Address matched flag (Slave mode)”ENDAD”
1009
*                       - I2C_FLAG_SB: Start bit flag (Master mode)
1010
* Output         : None
1011
* Return         : None
1012
*******************************************************************************/
1013
void I2C_ClearFlag(I2C_TypeDef* I2Cx, u32 I2C_FLAG)
1014
{
1015
  u32 flagpos = 0;
1016
  u8 flagindex = 0;
1017
 
1018
  /* Check the parameters */
1019
  assert(IS_I2C_CLEAR_FLAG(I2C_FLAG));
1020
 
1021
  /* Get the I2C flag position */
1022
  flagpos = I2C_FLAG & I2C_FLAG_Mask;
1023
 
1024
  /* Get the I2C flag index */
1025
  flagindex = I2C_FLAG >> 28;
1026
 
1027
  /* Clear the flag by writing 0 */
1028
  if (flagindex == 1)
1029
  {
1030
    /* Clear the selected I2C flag */
1031
    I2Cx->SR1 &= ~flagpos;
1032
  }
1033
  /* Flags that need a read of the SR1 register to be cleared */
1034
  else if (flagindex == 2)
1035
  {
1036
    /* Read the SR1 register */
1037
    (void)I2Cx->SR1;
1038
  }
1039
  /* Flags that need a read of SR1 and a write on CR2 registers to be cleared */
1040
  else if (flagindex == 6)
1041
  {
1042
    /* Read the SR1 register */
1043
    (void)I2Cx->SR1;
1044
 
1045
    /* Write on the CR1 register */
1046
    I2Cx->CR1 |= CR1_PE_Set;
1047
  }
1048
  /* Flags that need a read of SR1 and a write on CR2 registers to be cleared */
1049
  else /*flagindex == 0xA*/
1050
  {
1051
    /* Read the SR1 register */
1052
    (void)I2Cx->SR1;
1053
 
1054
    /* Read the SR2 register */
1055
    (void)I2Cx->SR2;
1056
  }
1057
}
1058
 
1059
/*******************************************************************************
1060
* Function Name  : I2C_GetITStatus
1061
* Description    : Checks whether the specified I2C interrupt has occurred or not.
1062
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
1063
*                  - I2C_IT: specifies the interrupt source to check.
1064
*                    This parameter can be one of the following values:
1065
*                       - I2C_IT_SMBALERT: SMBus Alert flag
1066
*                       - I2C_IT_TIMEOUT: Timeout or Tlow error flag
1067
*                       - I2C_IT_PECERR: PEC error in reception flag
1068
*                       - I2C_IT_OVR: Overrun/Underrun flag (Slave mode)
1069
*                       - I2C_IT_AF: Acknowledge failure flag
1070
*                       - I2C_IT_ARLO: Arbitration lost flag (Master mode)
1071
*                       - I2C_IT_BERR: Bus error flag
1072
*                       - I2C_IT_TXE: Data register empty flag (Transmitter)
1073
*                       - I2C_IT_RXNE: Data register not empty (Receiver) flag
1074
*                       - I2C_IT_STOPF: Stop detection flag (Slave mode)
1075
*                       - I2C_IT_ADD10: 10-bit header sent flag (Master mode)
1076
*                       - I2C_IT_BTF: Byte transfer finished flag
1077
*                       - I2C_IT_ADDR: Address sent flag (Master mode) “ADSL”
1078
*                                        Address matched flag (Slave mode)”ENDAD”
1079
*                       - I2C_IT_SB: Start bit flag (Master mode)
1080
* Output         : None
1081
* Return         : The new state of I2C_IT (SET or RESET).
1082
*******************************************************************************/
1083
ITStatus I2C_GetITStatus(I2C_TypeDef* I2Cx, u32 I2C_IT)
1084
{
1085
  ITStatus bitstatus = RESET;
1086
  u32 i2cstatus = 0;
1087
  u32 Flag1 = 0, Flag2 = 0;
1088
 
1089
  /* Check the parameters */
1090
  assert(IS_I2C_GET_IT(I2C_IT));
1091
 
1092
  /* Read the I2Cx status register */
1093
  Flag1 = I2Cx->SR1;
1094
  Flag2 = I2Cx->SR2;
1095
  Flag2 = (Flag2 & I2C_FLAG_Mask) << 16;
1096
 
1097
  /* Get the I2C status value */
1098
  i2cstatus = Flag1 | Flag2;
1099
 
1100
  /* Get bit[27:0] of the flag */
1101
  I2C_IT &= I2C_FLAG_Mask;
1102
 
1103
  /* Check the status of the specified I2C flag */
1104
  if ((i2cstatus & I2C_IT) != (u32)RESET)
1105
  {
1106
    /* I2C_IT is set */
1107
    bitstatus = SET;
1108
  }
1109
  else
1110
  {
1111
    /* I2C_IT is reset */
1112
    bitstatus = RESET;
1113
  }
1114
  /* Return the I2C_IT status */
1115
  return  bitstatus;
1116
}
1117
 
1118
/*******************************************************************************
1119
* Function Name  : I2C_ClearITPendingBit
1120
* Description    : Clears the I2Cx’s interrupt pending bits.
1121
* Input          : - I2Cx: where x can be 1 or 2 to select the I2C peripheral.
1122
*                  - I2C_IT: specifies the interrupt pending to clear.
1123
*                    This parameter can be one of the following values:
1124
*                       - I2C_IT_SMBALERT: SMBus Alert flag
1125
*                       - I2C_IT_TIMEOUT: Timeout or Tlow error flag
1126
*                       - I2C_IT_PECERR: PEC error in reception flag
1127
*                       - I2C_IT_OVR: Overrun/Underrun flag (Slave mode)
1128
*                       - I2C_IT_AF: Acknowledge failure flag
1129
*                       - I2C_IT_ARLO: Arbitration lost flag (Master mode)
1130
*                       - I2C_IT_BERR: Bus error flag
1131
*                       - I2C_IT_STOPF: Stop detection flag (Slave mode)
1132
*                       - I2C_IT_ADD10: 10-bit header sent flag (Master mode)
1133
*                       - I2C_IT_BTF: Byte transfer finished flag
1134
*                       - I2C_IT_ADDR: Address sent flag (Master mode) “ADSL”
1135
*                                        Address matched flag (Slave mode)”ENDAD”
1136
*                       - I2C_IT_SB: Start bit flag (Master mode)
1137
* Output         : None
1138
* Return         : None
1139
*******************************************************************************/
1140
void I2C_ClearITPendingBit(I2C_TypeDef* I2Cx, u32 I2C_IT)
1141
{
1142
  u32 flagpos = 0;
1143
  u8 flagindex = 0;
1144
 
1145
  /* Check the parameters */
1146
  assert(IS_I2C_CLEAR_IT(I2C_IT));
1147
 
1148
  /* Get the I2C flag position */
1149
  flagpos = I2C_IT & I2C_FLAG_Mask;
1150
 
1151
  /* Get the I2C flag index */
1152
  flagindex = I2C_IT >> 28;
1153
 
1154
  /* Clear the flag by writing 0 */
1155
  if (flagindex == 1)
1156
  {
1157
    /* Clear the selected I2C flag */
1158
    I2Cx->SR1 &= ~flagpos;
1159
  }
1160
  /* Flags that need a read of the SR1 register to be cleared */
1161
  else if (flagindex == 2)
1162
  {
1163
    /* Read the SR1 register */
1164
    (void)I2Cx->SR1;
1165
  }
1166
  /* Flags that need a read of SR1 and a write on CR2 registers to be cleared */
1167
  else if (flagindex == 6)
1168
  {
1169
    /* Read the SR1 register */
1170
    (void)I2Cx->SR1;
1171
 
1172
    /* Write on the CR1 register */
1173
    I2Cx->CR1 |= CR1_PE_Set;
1174
  }
1175
  /* Flags that need a read of SR1 and a write on CR2 registers to be cleared */
1176
  else /*flagindex == 0xA*/
1177
  {
1178
    /* Read the SR1 register */
1179
    (void)I2Cx->SR1;
1180
 
1181
    /* Read the SR2 register */
1182
    (void)I2Cx->SR2;
1183
  }
1184
}
1185
 
1186
/******************* (C) COPYRIGHT 2007 STMicroelectronics *****END OF FILE****/

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.