drivers/i2c/busses/i2c-stm32f7.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Driver for STMicroelectronics STM32F7 I2C controller
   4  *
   5  * This I2C controller is described in the STM32F75xxx and STM32F74xxx Soc
   6  * reference manual.
   7  * Please see below a link to the documentation:
   8  * http://www.st.com/resource/en/reference_manual/dm00124865.pdf
   9  *
  10  * Copyright (C) M'boumba Cedric Madianga 2017
  11  * Copyright (C) STMicroelectronics 2017
  12  * Author: M'boumba Cedric Madianga <cedric.madianga@gmail.com>
  13  *
  14  * This driver is based on i2c-stm32f4.c
  15  *
  16  */
  17 #include <linux/clk.h>
  18 #include <linux/delay.h>
  19 #include <linux/err.h>
  20 #include <linux/i2c.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/io.h>
  23 #include <linux/iopoll.h>
  24 #include <linux/module.h>
  25 #include <linux/of.h>
  26 #include <linux/of_address.h>
  27 #include <linux/of_platform.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/reset.h>
  30 #include <linux/slab.h>
  31
  32 #include "i2c-stm32.h"
  33
  34 /* STM32F7 I2C registers */
  35 #define STM32F7_I2C_CR1                         0x00
  36 #define STM32F7_I2C_CR2                         0x04
  37 #define STM32F7_I2C_OAR1                        0x08
  38 #define STM32F7_I2C_OAR2                        0x0C
  39 #define STM32F7_I2C_PECR                        0x20
  40 #define STM32F7_I2C_TIMINGR                     0x10
  41 #define STM32F7_I2C_ISR                         0x18
  42 #define STM32F7_I2C_ICR                         0x1C
  43 #define STM32F7_I2C_RXDR                        0x24
  44 #define STM32F7_I2C_TXDR                        0x28
  45
  46 /* STM32F7 I2C control 1 */
  47 #define STM32F7_I2C_CR1_PECEN                   BIT(23)
  48 #define STM32F7_I2C_CR1_SBC                     BIT(16)
  49 #define STM32F7_I2C_CR1_RXDMAEN                 BIT(15)
  50 #define STM32F7_I2C_CR1_TXDMAEN                 BIT(14)
  51 #define STM32F7_I2C_CR1_ANFOFF                  BIT(12)
  52 #define STM32F7_I2C_CR1_DNF_MASK                GENMASK(11, 8)
  53 #define STM32F7_I2C_CR1_DNF(n)                  (((n) & 0xf) << 8)
  54 #define STM32F7_I2C_CR1_ERRIE                   BIT(7)
  55 #define STM32F7_I2C_CR1_TCIE                    BIT(6)
  56 #define STM32F7_I2C_CR1_STOPIE                  BIT(5)
  57 #define STM32F7_I2C_CR1_NACKIE                  BIT(4)
  58 #define STM32F7_I2C_CR1_ADDRIE                  BIT(3)
  59 #define STM32F7_I2C_CR1_RXIE                    BIT(2)
  60 #define STM32F7_I2C_CR1_TXIE                    BIT(1)
  61 #define STM32F7_I2C_CR1_PE                      BIT(0)
  62 #define STM32F7_I2C_ALL_IRQ_MASK                (STM32F7_I2C_CR1_ERRIE \
  63                                                 | STM32F7_I2C_CR1_TCIE \
  64                                                 | STM32F7_I2C_CR1_STOPIE \
  65                                                 | STM32F7_I2C_CR1_NACKIE \
  66                                                 | STM32F7_I2C_CR1_RXIE \
  67                                                 | STM32F7_I2C_CR1_TXIE)
  68 #define STM32F7_I2C_XFER_IRQ_MASK               (STM32F7_I2C_CR1_TCIE \
  69                                                 | STM32F7_I2C_CR1_STOPIE \
  70                                                 | STM32F7_I2C_CR1_NACKIE \
  71                                                 | STM32F7_I2C_CR1_RXIE \
  72                                                 | STM32F7_I2C_CR1_TXIE)
  73
  74 /* STM32F7 I2C control 2 */
  75 #define STM32F7_I2C_CR2_PECBYTE                 BIT(26)
  76 #define STM32F7_I2C_CR2_RELOAD                  BIT(24)
  77 #define STM32F7_I2C_CR2_NBYTES_MASK             GENMASK(23, 16)
  78 #define STM32F7_I2C_CR2_NBYTES(n)               (((n) & 0xff) << 16)
  79 #define STM32F7_I2C_CR2_NACK                    BIT(15)
  80 #define STM32F7_I2C_CR2_STOP                    BIT(14)
  81 #define STM32F7_I2C_CR2_START                   BIT(13)
  82 #define STM32F7_I2C_CR2_HEAD10R                 BIT(12)
  83 #define STM32F7_I2C_CR2_ADD10                   BIT(11)
  84 #define STM32F7_I2C_CR2_RD_WRN                  BIT(10)
  85 #define STM32F7_I2C_CR2_SADD10_MASK             GENMASK(9, 0)
  86 #define STM32F7_I2C_CR2_SADD10(n)               (((n) & \
  87                                                 STM32F7_I2C_CR2_SADD10_MASK))
  88 #define STM32F7_I2C_CR2_SADD7_MASK              GENMASK(7, 1)
  89 #define STM32F7_I2C_CR2_SADD7(n)                (((n) & 0x7f) << 1)
  90
  91 /* STM32F7 I2C Own Address 1 */
  92 #define STM32F7_I2C_OAR1_OA1EN                  BIT(15)
  93 #define STM32F7_I2C_OAR1_OA1MODE                BIT(10)
  94 #define STM32F7_I2C_OAR1_OA1_10_MASK            GENMASK(9, 0)
  95 #define STM32F7_I2C_OAR1_OA1_10(n)              (((n) & \
  96                                                 STM32F7_I2C_OAR1_OA1_10_MASK))
  97 #define STM32F7_I2C_OAR1_OA1_7_MASK             GENMASK(7, 1)
  98 #define STM32F7_I2C_OAR1_OA1_7(n)               (((n) & 0x7f) << 1)
  99 #define STM32F7_I2C_OAR1_MASK                   (STM32F7_I2C_OAR1_OA1_7_MASK \
 100                                                 | STM32F7_I2C_OAR1_OA1_10_MASK \
 101                                                 | STM32F7_I2C_OAR1_OA1EN \
 102                                                 | STM32F7_I2C_OAR1_OA1MODE)
 103
 104 /* STM32F7 I2C Own Address 2 */
 105 #define STM32F7_I2C_OAR2_OA2EN                  BIT(15)
 106 #define STM32F7_I2C_OAR2_OA2MSK_MASK            GENMASK(10, 8)
 107 #define STM32F7_I2C_OAR2_OA2MSK(n)              (((n) & 0x7) << 8)
 108 #define STM32F7_I2C_OAR2_OA2_7_MASK             GENMASK(7, 1)
 109 #define STM32F7_I2C_OAR2_OA2_7(n)               (((n) & 0x7f) << 1)
 110 #define STM32F7_I2C_OAR2_MASK                   (STM32F7_I2C_OAR2_OA2MSK_MASK \
 111                                                 | STM32F7_I2C_OAR2_OA2_7_MASK \
 112                                                 | STM32F7_I2C_OAR2_OA2EN)
 113
 114 /* STM32F7 I2C Interrupt Status */
 115 #define STM32F7_I2C_ISR_ADDCODE_MASK            GENMASK(23, 17)
 116 #define STM32F7_I2C_ISR_ADDCODE_GET(n) \
 117                                 (((n) & STM32F7_I2C_ISR_ADDCODE_MASK) >> 17)
 118 #define STM32F7_I2C_ISR_DIR                     BIT(16)
 119 #define STM32F7_I2C_ISR_BUSY                    BIT(15)
 120 #define STM32F7_I2C_ISR_PECERR                  BIT(11)
 121 #define STM32F7_I2C_ISR_ARLO                    BIT(9)
 122 #define STM32F7_I2C_ISR_BERR                    BIT(8)
 123 #define STM32F7_I2C_ISR_TCR                     BIT(7)
 124 #define STM32F7_I2C_ISR_TC                      BIT(6)
 125 #define STM32F7_I2C_ISR_STOPF                   BIT(5)
 126 #define STM32F7_I2C_ISR_NACKF                   BIT(4)
 127 #define STM32F7_I2C_ISR_ADDR                    BIT(3)
 128 #define STM32F7_I2C_ISR_RXNE                    BIT(2)
 129 #define STM32F7_I2C_ISR_TXIS                    BIT(1)
 130 #define STM32F7_I2C_ISR_TXE                     BIT(0)
 131
 132 /* STM32F7 I2C Interrupt Clear */
 133 #define STM32F7_I2C_ICR_PECCF                   BIT(11)
 134 #define STM32F7_I2C_ICR_ARLOCF                  BIT(9)
 135 #define STM32F7_I2C_ICR_BERRCF                  BIT(8)
 136 #define STM32F7_I2C_ICR_STOPCF                  BIT(5)
 137 #define STM32F7_I2C_ICR_NACKCF                  BIT(4)
 138 #define STM32F7_I2C_ICR_ADDRCF                  BIT(3)
 139
 140 /* STM32F7 I2C Timing */
 141 #define STM32F7_I2C_TIMINGR_PRESC(n)            (((n) & 0xf) << 28)
 142 #define STM32F7_I2C_TIMINGR_SCLDEL(n)           (((n) & 0xf) << 20)
 143 #define STM32F7_I2C_TIMINGR_SDADEL(n)           (((n) & 0xf) << 16)
 144 #define STM32F7_I2C_TIMINGR_SCLH(n)             (((n) & 0xff) << 8)
 145 #define STM32F7_I2C_TIMINGR_SCLL(n)             ((n) & 0xff)
 146
 147 #define STM32F7_I2C_MAX_LEN                     0xff
 148 #define STM32F7_I2C_DMA_LEN_MIN                 0x16
 149 #define STM32F7_I2C_MAX_SLAVE                   0x2
 150
 151 #define STM32F7_I2C_DNF_DEFAULT                 0
 152 #define STM32F7_I2C_DNF_MAX                     15
 153
 154 #define STM32F7_I2C_ANALOG_FILTER_ENABLE        1
 155 #define STM32F7_I2C_ANALOG_FILTER_DELAY_MIN     50      /* ns */
 156 #define STM32F7_I2C_ANALOG_FILTER_DELAY_MAX     260     /* ns */
 157
 158 #define STM32F7_I2C_RISE_TIME_DEFAULT           25      /* ns */
 159 #define STM32F7_I2C_FALL_TIME_DEFAULT           10      /* ns */
 160
 161 #define STM32F7_PRESC_MAX                       BIT(4)
 162 #define STM32F7_SCLDEL_MAX                      BIT(4)
 163 #define STM32F7_SDADEL_MAX                      BIT(4)
 164 #define STM32F7_SCLH_MAX                        BIT(8)
 165 #define STM32F7_SCLL_MAX                        BIT(8)
 166
 167 /**
 168  * struct stm32f7_i2c_spec - private i2c specification timing
 169  * @rate: I2C bus speed (Hz)
 170  * @rate_min: 80% of I2C bus speed (Hz)
 171  * @rate_max: 100% of I2C bus speed (Hz)
 172  * @fall_max: Max fall time of both SDA and SCL signals (ns)
 173  * @rise_max: Max rise time of both SDA and SCL signals (ns)
 174  * @hddat_min: Min data hold time (ns)
 175  * @vddat_max: Max data valid time (ns)
 176  * @sudat_min: Min data setup time (ns)
 177  * @l_min: Min low period of the SCL clock (ns)
 178  * @h_min: Min high period of the SCL clock (ns)
 179  */
 180 struct stm32f7_i2c_spec {
 181         u32 rate;
 182         u32 rate_min;
 183         u32 rate_max;
 184         u32 fall_max;
 185         u32 rise_max;
 186         u32 hddat_min;
 187         u32 vddat_max;
 188         u32 sudat_min;
 189         u32 l_min;
 190         u32 h_min;
 191 };
 192
 193 /**
 194  * struct stm32f7_i2c_setup - private I2C timing setup parameters
 195  * @speed: I2C speed mode (standard, Fast Plus)
 196  * @speed_freq: I2C speed frequency  (Hz)
 197  * @clock_src: I2C clock source frequency (Hz)
 198  * @rise_time: Rise time (ns)
 199  * @fall_time: Fall time (ns)
 200  * @dnf: Digital filter coefficient (0-16)
 201  * @analog_filter: Analog filter delay (On/Off)
 202  */
 203 struct stm32f7_i2c_setup {
 204         enum stm32_i2c_speed speed;
 205         u32 speed_freq;
 206         u32 clock_src;
 207         u32 rise_time;
 208         u32 fall_time;
 209         u8 dnf;
 210         bool analog_filter;
 211 };
 212
 213 /**
 214  * struct stm32f7_i2c_timings - private I2C output parameters
 215  * @node: List entry
 216  * @presc: Prescaler value
 217  * @scldel: Data setup time
 218  * @sdadel: Data hold time
 219  * @sclh: SCL high period (master mode)
 220  * @scll: SCL low period (master mode)
 221  */
 222 struct stm32f7_i2c_timings {
 223         struct list_head node;
 224         u8 presc;
 225         u8 scldel;
 226         u8 sdadel;
 227         u8 sclh;
 228         u8 scll;
 229 };
 230
 231 /**
 232  * struct stm32f7_i2c_msg - client specific data
 233  * @addr: 8-bit or 10-bit slave addr, including r/w bit
 234  * @count: number of bytes to be transferred
 235  * @buf: data buffer
 236  * @result: result of the transfer
 237  * @stop: last I2C msg to be sent, i.e. STOP to be generated
 238  * @smbus: boolean to know if the I2C IP is used in SMBus mode
 239  * @size: type of SMBus protocol
 240  * @read_write: direction of SMBus protocol
 241  * SMBus block read and SMBus block write - block read process call protocols
 242  * @smbus_buf: buffer to be used for SMBus protocol transfer. It will
 243  * contain a maximum of 32 bytes of data + byte command + byte count + PEC
 244  * This buffer has to be 32-bit aligned to be compliant with memory address
 245  * register in DMA mode.
 246  */
 247 struct stm32f7_i2c_msg {
 248         u16 addr;
 249         u32 count;
 250         u8 *buf;
 251         int result;
 252         bool stop;
 253         bool smbus;
 254         int size;
 255         char read_write;
 256         u8 smbus_buf[I2C_SMBUS_BLOCK_MAX + 3] __aligned(4);
 257 };
 258
 259 /**
 260  * struct stm32f7_i2c_dev - private data of the controller
 261  * @adap: I2C adapter for this controller
 262  * @dev: device for this controller
 263  * @base: virtual memory area
 264  * @complete: completion of I2C message
 265  * @clk: hw i2c clock
 266  * @speed: I2C clock frequency of the controller. Standard, Fast or Fast+
 267  * @msg: Pointer to data to be written
 268  * @msg_num: number of I2C messages to be executed
 269  * @msg_id: message identifiant
 270  * @f7_msg: customized i2c msg for driver usage
 271  * @setup: I2C timing input setup
 272  * @timing: I2C computed timings
 273  * @slave: list of slave devices registered on the I2C bus
 274  * @slave_running: slave device currently used
 275  * @slave_dir: transfer direction for the current slave device
 276  * @master_mode: boolean to know in which mode the I2C is running (master or
 277  * slave)
 278  * @dma: dma data
 279  * @use_dma: boolean to know if dma is used in the current transfer
 280  */
 281 struct stm32f7_i2c_dev {
 282         struct i2c_adapter adap;
 283         struct device *dev;
 284         void __iomem *base;
 285         struct completion complete;
 286         struct clk *clk;
 287         int speed;
 288         struct i2c_msg *msg;
 289         unsigned int msg_num;
 290         unsigned int msg_id;
 291         struct stm32f7_i2c_msg f7_msg;
 292         struct stm32f7_i2c_setup setup;
 293         struct stm32f7_i2c_timings timing;
 294         struct i2c_client *slave[STM32F7_I2C_MAX_SLAVE];
 295         struct i2c_client *slave_running;
 296         u32 slave_dir;
 297         bool master_mode;
 298         struct stm32_i2c_dma *dma;
 299         bool use_dma;
 300 };
 301
 302 /*
 303  * All these values are coming from I2C Specification, Version 6.0, 4th of
 304  * April 2014.
 305  *
 306  * Table10. Characteristics of the SDA and SCL bus lines for Standard, Fast,
 307  * and Fast-mode Plus I2C-bus devices
 308  */
 309 static struct stm32f7_i2c_spec i2c_specs[] = {
 310         [STM32_I2C_SPEED_STANDARD] = {
 311                 .rate = 100000,
 312                 .rate_min = 80000,
 313                 .rate_max = 100000,
 314                 .fall_max = 300,
 315                 .rise_max = 1000,
 316                 .hddat_min = 0,
 317                 .vddat_max = 3450,
 318                 .sudat_min = 250,
 319                 .l_min = 4700,
 320                 .h_min = 4000,
 321         },
 322         [STM32_I2C_SPEED_FAST] = {
 323                 .rate = 400000,
 324                 .rate_min = 320000,
 325                 .rate_max = 400000,
 326                 .fall_max = 300,
 327                 .rise_max = 300,
 328                 .hddat_min = 0,
 329                 .vddat_max = 900,
 330                 .sudat_min = 100,
 331                 .l_min = 1300,
 332                 .h_min = 600,
 333         },
 334         [STM32_I2C_SPEED_FAST_PLUS] = {
 335                 .rate = 1000000,
 336                 .rate_min = 800000,
 337                 .rate_max = 1000000,
 338                 .fall_max = 100,
 339                 .rise_max = 120,
 340                 .hddat_min = 0,
 341                 .vddat_max = 450,
 342                 .sudat_min = 50,
 343                 .l_min = 500,
 344                 .h_min = 260,
 345         },
 346 };
 347
 348 static const struct stm32f7_i2c_setup stm32f7_setup = {
 349         .rise_time = STM32F7_I2C_RISE_TIME_DEFAULT,
 350         .fall_time = STM32F7_I2C_FALL_TIME_DEFAULT,
 351         .dnf = STM32F7_I2C_DNF_DEFAULT,
 352         .analog_filter = STM32F7_I2C_ANALOG_FILTER_ENABLE,
 353 };
 354
 355 static inline void stm32f7_i2c_set_bits(void __iomem *reg, u32 mask)
 356 {
 357         writel_relaxed(readl_relaxed(reg) | mask, reg);
 358 }
 359
 360 static inline void stm32f7_i2c_clr_bits(void __iomem *reg, u32 mask)
 361 {
 362         writel_relaxed(readl_relaxed(reg) & ~mask, reg);
 363 }
 364
 365 static void stm32f7_i2c_disable_irq(struct stm32f7_i2c_dev *i2c_dev, u32 mask)
 366 {
 367         stm32f7_i2c_clr_bits(i2c_dev->base + STM32F7_I2C_CR1, mask);
 368 }
 369
 370 static int stm32f7_i2c_compute_timing(struct stm32f7_i2c_dev *i2c_dev,
 371                                       struct stm32f7_i2c_setup *setup,
 372                                       struct stm32f7_i2c_timings *output)
 373 {
 374         u32 p_prev = STM32F7_PRESC_MAX;
 375         u32 i2cclk = DIV_ROUND_CLOSEST(NSEC_PER_SEC,
 376                                        setup->clock_src);
 377         u32 i2cbus = DIV_ROUND_CLOSEST(NSEC_PER_SEC,
 378                                        setup->speed_freq);
 379         u32 clk_error_prev = i2cbus;
 380         u32 tsync;
 381         u32 af_delay_min, af_delay_max;
 382         u32 dnf_delay;
 383         u32 clk_min, clk_max;
 384         int sdadel_min, sdadel_max;
 385         int scldel_min;
 386         struct stm32f7_i2c_timings *v, *_v, *s;
 387         struct list_head solutions;
 388         u16 p, l, a, h;
 389         int ret = 0;
 390
 391         if (setup->speed >= STM32_I2C_SPEED_END) {
 392                 dev_err(i2c_dev->dev, "speed out of bound {%d/%d}\n",
 393                         setup->speed, STM32_I2C_SPEED_END - 1);
 394                 return -EINVAL;
 395         }
 396
 397         if ((setup->rise_time > i2c_specs[setup->speed].rise_max) ||
 398             (setup->fall_time > i2c_specs[setup->speed].fall_max)) {
 399                 dev_err(i2c_dev->dev,
 400                         "timings out of bound Rise{%d>%d}/Fall{%d>%d}\n",
 401                         setup->rise_time, i2c_specs[setup->speed].rise_max,
 402                         setup->fall_time, i2c_specs[setup->speed].fall_max);
 403                 return -EINVAL;
 404         }
 405
 406         if (setup->dnf > STM32F7_I2C_DNF_MAX) {
 407                 dev_err(i2c_dev->dev,
 408                         "DNF out of bound %d/%d\n",
 409                         setup->dnf, STM32F7_I2C_DNF_MAX);
 410                 return -EINVAL;
 411         }
 412
 413         if (setup->speed_freq > i2c_specs[setup->speed].rate) {
 414                 dev_err(i2c_dev->dev, "ERROR: Freq {%d/%d}\n",
 415                         setup->speed_freq, i2c_specs[setup->speed].rate);
 416                 return -EINVAL;
 417         }
 418
 419         /*  Analog and Digital Filters */
 420         af_delay_min =
 421                 (setup->analog_filter ?
 422                  STM32F7_I2C_ANALOG_FILTER_DELAY_MIN : 0);
 423         af_delay_max =
 424                 (setup->analog_filter ?
 425                  STM32F7_I2C_ANALOG_FILTER_DELAY_MAX : 0);
 426         dnf_delay = setup->dnf * i2cclk;
 427
 428         sdadel_min = i2c_specs[setup->speed].hddat_min + setup->fall_time -
 429                 af_delay_min - (setup->dnf + 3) * i2cclk;
 430
 431         sdadel_max = i2c_specs[setup->speed].vddat_max - setup->rise_time -
 432                 af_delay_max - (setup->dnf + 4) * i2cclk;
 433
 434         scldel_min = setup->rise_time + i2c_specs[setup->speed].sudat_min;
 435
 436         if (sdadel_min < 0)
 437                 sdadel_min = 0;
 438         if (sdadel_max < 0)
 439                 sdadel_max = 0;
 440
 441         dev_dbg(i2c_dev->dev, "SDADEL(min/max): %i/%i, SCLDEL(Min): %i\n",
 442                 sdadel_min, sdadel_max, scldel_min);
 443
 444         INIT_LIST_HEAD(&solutions);
 445         /* Compute possible values for PRESC, SCLDEL and SDADEL */
 446         for (p = 0; p < STM32F7_PRESC_MAX; p++) {
 447                 for (l = 0; l < STM32F7_SCLDEL_MAX; l++) {
 448                         u32 scldel = (l + 1) * (p + 1) * i2cclk;
 449
 450                         if (scldel < scldel_min)
 451                                 continue;
 452
 453                         for (a = 0; a < STM32F7_SDADEL_MAX; a++) {
 454                                 u32 sdadel = (a * (p + 1) + 1) * i2cclk;
 455
 456                                 if (((sdadel >= sdadel_min) &&
 457                                      (sdadel <= sdadel_max)) &&
 458                                     (p != p_prev)) {
 459                                         v = kmalloc(sizeof(*v), GFP_KERNEL);
 460                                         if (!v) {
 461                                                 ret = -ENOMEM;
 462                                                 goto exit;
 463                                         }
 464
 465                                         v->presc = p;
 466                                         v->scldel = l;
 467                                         v->sdadel = a;
 468                                         p_prev = p;
 469
 470                                         list_add_tail(&v->node,
 471                                                       &solutions);
 472                                 }
 473                         }
 474                 }
 475         }
 476
 477         if (list_empty(&solutions)) {
 478                 dev_err(i2c_dev->dev, "no Prescaler solution\n");
 479                 ret = -EPERM;
 480                 goto exit;
 481         }
 482
 483         tsync = af_delay_min + dnf_delay + (2 * i2cclk);
 484         s = NULL;
 485         clk_max = NSEC_PER_SEC / i2c_specs[setup->speed].rate_min;
 486         clk_min = NSEC_PER_SEC / i2c_specs[setup->speed].rate_max;
 487
 488         /*
 489          * Among Prescaler possibilities discovered above figures out SCL Low
 490          * and High Period. Provided:
 491          * - SCL Low Period has to be higher than SCL Clock Low Period
 492          *   defined by I2C Specification. I2C Clock has to be lower than
 493          *   (SCL Low Period - Analog/Digital filters) / 4.
 494          * - SCL High Period has to be lower than SCL Clock High Period
 495          *   defined by I2C Specification
 496          * - I2C Clock has to be lower than SCL High Period
 497          */
 498         list_for_each_entry(v, &solutions, node) {
 499                 u32 prescaler = (v->presc + 1) * i2cclk;
 500
 501                 for (l = 0; l < STM32F7_SCLL_MAX; l++) {
 502                         u32 tscl_l = (l + 1) * prescaler + tsync;
 503
 504                         if ((tscl_l < i2c_specs[setup->speed].l_min) ||
 505                             (i2cclk >=
 506                              ((tscl_l - af_delay_min - dnf_delay) / 4))) {
 507                                 continue;
 508                         }
 509
 510                         for (h = 0; h < STM32F7_SCLH_MAX; h++) {
 511                                 u32 tscl_h = (h + 1) * prescaler + tsync;
 512                                 u32 tscl = tscl_l + tscl_h +
 513                                         setup->rise_time + setup->fall_time;
 514
 515                                 if ((tscl >= clk_min) && (tscl <= clk_max) &&
 516                                     (tscl_h >= i2c_specs[setup->speed].h_min) &&
 517                                     (i2cclk < tscl_h)) {
 518                                         int clk_error = tscl - i2cbus;
 519
 520                                         if (clk_error < 0)
 521                                                 clk_error = -clk_error;
 522
 523                                         if (clk_error < clk_error_prev) {
 524                                                 clk_error_prev = clk_error;
 525                                                 v->scll = l;
 526                                                 v->sclh = h;
 527                                                 s = v;
 528                                         }
 529                                 }
 530                         }
 531                 }
 532         }
 533
 534         if (!s) {
 535                 dev_err(i2c_dev->dev, "no solution at all\n");
 536                 ret = -EPERM;
 537                 goto exit;
 538         }
 539
 540         output->presc = s->presc;
 541         output->scldel = s->scldel;
 542         output->sdadel = s->sdadel;
 543         output->scll = s->scll;
 544         output->sclh = s->sclh;
 545
 546         dev_dbg(i2c_dev->dev,
 547                 "Presc: %i, scldel: %i, sdadel: %i, scll: %i, sclh: %i\n",
 548                 output->presc,
 549                 output->scldel, output->sdadel,
 550                 output->scll, output->sclh);
 551
 552 exit:
 553         /* Release list and memory */
 554         list_for_each_entry_safe(v, _v, &solutions, node) {
 555                 list_del(&v->node);
 556                 kfree(v);
 557         }
 558
 559         return ret;
 560 }
 561
 562 static int stm32f7_i2c_setup_timing(struct stm32f7_i2c_dev *i2c_dev,
 563                                     struct stm32f7_i2c_setup *setup)
 564 {
 565         int ret = 0;
 566
 567         setup->speed = i2c_dev->speed;
 568         setup->speed_freq = i2c_specs[setup->speed].rate;
 569         setup->clock_src = clk_get_rate(i2c_dev->clk);
 570
 571         if (!setup->clock_src) {
 572                 dev_err(i2c_dev->dev, "clock rate is 0\n");
 573                 return -EINVAL;
 574         }
 575
 576         do {
 577                 ret = stm32f7_i2c_compute_timing(i2c_dev, setup,
 578                                                  &i2c_dev->timing);
 579                 if (ret) {
 580                         dev_err(i2c_dev->dev,
 581                                 "failed to compute I2C timings.\n");
 582                         if (i2c_dev->speed > STM32_I2C_SPEED_STANDARD) {
 583                                 i2c_dev->speed--;
 584                                 setup->speed = i2c_dev->speed;
 585                                 setup->speed_freq =
 586                                         i2c_specs[setup->speed].rate;
 587                                 dev_warn(i2c_dev->dev,
 588                                          "downgrade I2C Speed Freq to (%i)\n",
 589                                          i2c_specs[setup->speed].rate);
 590                         } else {
 591                                 break;
 592                         }
 593                 }
 594         } while (ret);
 595
 596         if (ret) {
 597                 dev_err(i2c_dev->dev, "Impossible to compute I2C timings.\n");
 598                 return ret;
 599         }
 600
 601         dev_dbg(i2c_dev->dev, "I2C Speed(%i), Freq(%i), Clk Source(%i)\n",
 602                 setup->speed, setup->speed_freq, setup->clock_src);
 603         dev_dbg(i2c_dev->dev, "I2C Rise(%i) and Fall(%i) Time\n",
 604                 setup->rise_time, setup->fall_time);
 605         dev_dbg(i2c_dev->dev, "I2C Analog Filter(%s), DNF(%i)\n",
 606                 (setup->analog_filter ? "On" : "Off"), setup->dnf);
 607
 608         return 0;
 609 }
 610
 611 static void stm32f7_i2c_disable_dma_req(struct stm32f7_i2c_dev *i2c_dev)
 612 {
 613         void __iomem *base = i2c_dev->base;
 614         u32 mask = STM32F7_I2C_CR1_RXDMAEN | STM32F7_I2C_CR1_TXDMAEN;
 615
 616         stm32f7_i2c_clr_bits(base + STM32F7_I2C_CR1, mask);
 617 }
 618
 619 static void stm32f7_i2c_dma_callback(void *arg)
 620 {
 621         struct stm32f7_i2c_dev *i2c_dev = (struct stm32f7_i2c_dev *)arg;
 622         struct stm32_i2c_dma *dma = i2c_dev->dma;
 623         struct device *dev = dma->chan_using->device->dev;
 624
 625         stm32f7_i2c_disable_dma_req(i2c_dev);
 626         dma_unmap_single(dev, dma->dma_buf, dma->dma_len, dma->dma_data_dir);
 627         complete(&dma->dma_complete);
 628 }
 629
 630 static void stm32f7_i2c_hw_config(struct stm32f7_i2c_dev *i2c_dev)
 631 {
 632         struct stm32f7_i2c_timings *t = &i2c_dev->timing;
 633         u32 timing = 0;
 634
 635         /* Timing settings */
 636         timing |= STM32F7_I2C_TIMINGR_PRESC(t->presc);
 637         timing |= STM32F7_I2C_TIMINGR_SCLDEL(t->scldel);
 638         timing |= STM32F7_I2C_TIMINGR_SDADEL(t->sdadel);
 639         timing |= STM32F7_I2C_TIMINGR_SCLH(t->sclh);
 640         timing |= STM32F7_I2C_TIMINGR_SCLL(t->scll);
 641         writel_relaxed(timing, i2c_dev->base + STM32F7_I2C_TIMINGR);
 642
 643         /* Enable I2C */
 644         if (i2c_dev->setup.analog_filter)
 645                 stm32f7_i2c_clr_bits(i2c_dev->base + STM32F7_I2C_CR1,
 646                                      STM32F7_I2C_CR1_ANFOFF);
 647         else
 648                 stm32f7_i2c_set_bits(i2c_dev->base + STM32F7_I2C_CR1,
 649                                      STM32F7_I2C_CR1_ANFOFF);
 650
 651         /* Program the Digital Filter */
 652         stm32f7_i2c_clr_bits(i2c_dev->base + STM32F7_I2C_CR1,
 653                              STM32F7_I2C_CR1_DNF_MASK);
 654         stm32f7_i2c_set_bits(i2c_dev->base + STM32F7_I2C_CR1,
 655                              STM32F7_I2C_CR1_DNF(i2c_dev->setup.dnf));
 656
 657         stm32f7_i2c_set_bits(i2c_dev->base + STM32F7_I2C_CR1,
 658                              STM32F7_I2C_CR1_PE);
 659 }
 660
 661 static void stm32f7_i2c_write_tx_data(struct stm32f7_i2c_dev *i2c_dev)
 662 {
 663         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
 664         void __iomem *base = i2c_dev->base;
 665
 666         if (f7_msg->count) {
 667                 writeb_relaxed(*f7_msg->buf++, base + STM32F7_I2C_TXDR);
 668                 f7_msg->count--;
 669         }
 670 }
 671
 672 static void stm32f7_i2c_read_rx_data(struct stm32f7_i2c_dev *i2c_dev)
 673 {
 674         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
 675         void __iomem *base = i2c_dev->base;
 676
 677         if (f7_msg->count) {
 678                 *f7_msg->buf++ = readb_relaxed(base + STM32F7_I2C_RXDR);
 679                 f7_msg->count--;
 680         } else {
 681                 /* Flush RX buffer has no data is expected */
 682                 readb_relaxed(base + STM32F7_I2C_RXDR);
 683         }
 684 }
 685
 686 static void stm32f7_i2c_reload(struct stm32f7_i2c_dev *i2c_dev)
 687 {
 688         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
 689         u32 cr2;
 690
 691         if (i2c_dev->use_dma)
 692                 f7_msg->count -= STM32F7_I2C_MAX_LEN;
 693
 694         cr2 = readl_relaxed(i2c_dev->base + STM32F7_I2C_CR2);
 695
 696         cr2 &= ~STM32F7_I2C_CR2_NBYTES_MASK;
 697         if (f7_msg->count > STM32F7_I2C_MAX_LEN) {
 698                 cr2 |= STM32F7_I2C_CR2_NBYTES(STM32F7_I2C_MAX_LEN);
 699         } else {
 700                 cr2 &= ~STM32F7_I2C_CR2_RELOAD;
 701                 cr2 |= STM32F7_I2C_CR2_NBYTES(f7_msg->count);
 702         }
 703
 704         writel_relaxed(cr2, i2c_dev->base + STM32F7_I2C_CR2);
 705 }
 706
 707 static void stm32f7_i2c_smbus_reload(struct stm32f7_i2c_dev *i2c_dev)
 708 {
 709         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
 710         u32 cr2;
 711         u8 *val;
 712
 713         /*
 714          * For I2C_SMBUS_BLOCK_DATA && I2C_SMBUS_BLOCK_PROC_CALL, the first
 715          * data received inform us how many data will follow.
 716          */
 717         stm32f7_i2c_read_rx_data(i2c_dev);
 718
 719         /*
 720          * Update NBYTES with the value read to continue the transfer
 721          */
 722         val = f7_msg->buf - sizeof(u8);
 723         f7_msg->count = *val;
 724         cr2 = readl_relaxed(i2c_dev->base + STM32F7_I2C_CR2);
 725         cr2 &= ~(STM32F7_I2C_CR2_NBYTES_MASK | STM32F7_I2C_CR2_RELOAD);
 726         cr2 |= STM32F7_I2C_CR2_NBYTES(f7_msg->count);
 727         writel_relaxed(cr2, i2c_dev->base + STM32F7_I2C_CR2);
 728 }
 729
 730 static int stm32f7_i2c_release_bus(struct i2c_adapter *i2c_adap)
 731 {
 732         struct stm32f7_i2c_dev *i2c_dev = i2c_get_adapdata(i2c_adap);
 733
 734         dev_info(i2c_dev->dev, "Trying to recover bus\n");
 735
 736         stm32f7_i2c_clr_bits(i2c_dev->base + STM32F7_I2C_CR1,
 737                              STM32F7_I2C_CR1_PE);
 738
 739         stm32f7_i2c_hw_config(i2c_dev);
 740
 741         return 0;
 742 }
 743
 744 static int stm32f7_i2c_wait_free_bus(struct stm32f7_i2c_dev *i2c_dev)
 745 {
 746         u32 status;
 747         int ret;
 748
 749         ret = readl_relaxed_poll_timeout(i2c_dev->base + STM32F7_I2C_ISR,
 750                                          status,
 751                                          !(status & STM32F7_I2C_ISR_BUSY),
 752                                          10, 1000);
 753         if (!ret)
 754                 return 0;
 755
 756         dev_info(i2c_dev->dev, "bus busy\n");
 757
 758         ret = stm32f7_i2c_release_bus(&i2c_dev->adap);
 759         if (ret) {
 760                 dev_err(i2c_dev->dev, "Failed to recover the bus (%d)\n", ret);
 761                 return ret;
 762         }
 763
 764         return -EBUSY;
 765 }
 766
 767 static void stm32f7_i2c_xfer_msg(struct stm32f7_i2c_dev *i2c_dev,
 768                                  struct i2c_msg *msg)
 769 {
 770         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
 771         void __iomem *base = i2c_dev->base;
 772         u32 cr1, cr2;
 773         int ret;
 774
 775         f7_msg->addr = msg->addr;
 776         f7_msg->buf = msg->buf;
 777         f7_msg->count = msg->len;
 778         f7_msg->result = 0;
 779         f7_msg->stop = (i2c_dev->msg_id >= i2c_dev->msg_num - 1);
 780
 781         reinit_completion(&i2c_dev->complete);
 782
 783         cr1 = readl_relaxed(base + STM32F7_I2C_CR1);
 784         cr2 = readl_relaxed(base + STM32F7_I2C_CR2);
 785
 786         /* Set transfer direction */
 787         cr2 &= ~STM32F7_I2C_CR2_RD_WRN;
 788         if (msg->flags & I2C_M_RD)
 789                 cr2 |= STM32F7_I2C_CR2_RD_WRN;
 790
 791         /* Set slave address */
 792         cr2 &= ~(STM32F7_I2C_CR2_HEAD10R | STM32F7_I2C_CR2_ADD10);
 793         if (msg->flags & I2C_M_TEN) {
 794                 cr2 &= ~STM32F7_I2C_CR2_SADD10_MASK;
 795                 cr2 |= STM32F7_I2C_CR2_SADD10(f7_msg->addr);
 796                 cr2 |= STM32F7_I2C_CR2_ADD10;
 797         } else {
 798                 cr2 &= ~STM32F7_I2C_CR2_SADD7_MASK;
 799                 cr2 |= STM32F7_I2C_CR2_SADD7(f7_msg->addr);
 800         }
 801
 802         /* Set nb bytes to transfer and reload if needed */
 803         cr2 &= ~(STM32F7_I2C_CR2_NBYTES_MASK | STM32F7_I2C_CR2_RELOAD);
 804         if (f7_msg->count > STM32F7_I2C_MAX_LEN) {
 805                 cr2 |= STM32F7_I2C_CR2_NBYTES(STM32F7_I2C_MAX_LEN);
 806                 cr2 |= STM32F7_I2C_CR2_RELOAD;
 807         } else {
 808                 cr2 |= STM32F7_I2C_CR2_NBYTES(f7_msg->count);
 809         }
 810
 811         /* Enable NACK, STOP, error and transfer complete interrupts */
 812         cr1 |= STM32F7_I2C_CR1_ERRIE | STM32F7_I2C_CR1_TCIE |
 813                 STM32F7_I2C_CR1_STOPIE | STM32F7_I2C_CR1_NACKIE;
 814
 815         /* Clear DMA req and TX/RX interrupt */
 816         cr1 &= ~(STM32F7_I2C_CR1_RXIE | STM32F7_I2C_CR1_TXIE |
 817                         STM32F7_I2C_CR1_RXDMAEN | STM32F7_I2C_CR1_TXDMAEN);
 818
 819         /* Configure DMA or enable RX/TX interrupt */
 820         i2c_dev->use_dma = false;
 821         if (i2c_dev->dma && f7_msg->count >= STM32F7_I2C_DMA_LEN_MIN) {
 822                 ret = stm32_i2c_prep_dma_xfer(i2c_dev->dev, i2c_dev->dma,
 823                                               msg->flags & I2C_M_RD,
 824                                               f7_msg->count, f7_msg->buf,
 825                                               stm32f7_i2c_dma_callback,
 826                                               i2c_dev);
 827                 if (!ret)
 828                         i2c_dev->use_dma = true;
 829                 else
 830                         dev_warn(i2c_dev->dev, "can't use DMA\n");
 831         }
 832
 833         if (!i2c_dev->use_dma) {
 834                 if (msg->flags & I2C_M_RD)
 835                         cr1 |= STM32F7_I2C_CR1_RXIE;
 836                 else
 837                         cr1 |= STM32F7_I2C_CR1_TXIE;
 838         } else {
 839                 if (msg->flags & I2C_M_RD)
 840                         cr1 |= STM32F7_I2C_CR1_RXDMAEN;
 841                 else
 842                         cr1 |= STM32F7_I2C_CR1_TXDMAEN;
 843         }
 844
 845         /* Configure Start/Repeated Start */
 846         cr2 |= STM32F7_I2C_CR2_START;
 847
 848         i2c_dev->master_mode = true;
 849
 850         /* Write configurations registers */
 851         writel_relaxed(cr1, base + STM32F7_I2C_CR1);
 852         writel_relaxed(cr2, base + STM32F7_I2C_CR2);
 853 }
 854
 855 static int stm32f7_i2c_smbus_xfer_msg(struct stm32f7_i2c_dev *i2c_dev,
 856                                       unsigned short flags, u8 command,
 857                                       union i2c_smbus_data *data)
 858 {
 859         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
 860         struct device *dev = i2c_dev->dev;
 861         void __iomem *base = i2c_dev->base;
 862         u32 cr1, cr2;
 863         int i, ret;
 864
 865         f7_msg->result = 0;
 866         reinit_completion(&i2c_dev->complete);
 867
 868         cr2 = readl_relaxed(base + STM32F7_I2C_CR2);
 869         cr1 = readl_relaxed(base + STM32F7_I2C_CR1);
 870
 871         /* Set transfer direction */
 872         cr2 &= ~STM32F7_I2C_CR2_RD_WRN;
 873         if (f7_msg->read_write)
 874                 cr2 |= STM32F7_I2C_CR2_RD_WRN;
 875
 876         /* Set slave address */
 877         cr2 &= ~(STM32F7_I2C_CR2_ADD10 | STM32F7_I2C_CR2_SADD7_MASK);
 878         cr2 |= STM32F7_I2C_CR2_SADD7(f7_msg->addr);
 879
 880         f7_msg->smbus_buf[0] = command;
 881         switch (f7_msg->size) {
 882         case I2C_SMBUS_QUICK:
 883                 f7_msg->stop = true;
 884                 f7_msg->count = 0;
 885                 break;
 886         case I2C_SMBUS_BYTE:
 887                 f7_msg->stop = true;
 888                 f7_msg->count = 1;
 889                 break;
 890         case I2C_SMBUS_BYTE_DATA:
 891                 if (f7_msg->read_write) {
 892                         f7_msg->stop = false;
 893                         f7_msg->count = 1;
 894                         cr2 &= ~STM32F7_I2C_CR2_RD_WRN;
 895                 } else {
 896                         f7_msg->stop = true;
 897                         f7_msg->count = 2;
 898                         f7_msg->smbus_buf[1] = data->byte;
 899                 }
 900                 break;
 901         case I2C_SMBUS_WORD_DATA:
 902                 if (f7_msg->read_write) {
 903                         f7_msg->stop = false;
 904                         f7_msg->count = 1;
 905                         cr2 &= ~STM32F7_I2C_CR2_RD_WRN;
 906                 } else {
 907                         f7_msg->stop = true;
 908                         f7_msg->count = 3;
 909                         f7_msg->smbus_buf[1] = data->word & 0xff;
 910                         f7_msg->smbus_buf[2] = data->word >> 8;
 911                 }
 912                 break;
 913         case I2C_SMBUS_BLOCK_DATA:
 914                 if (f7_msg->read_write) {
 915                         f7_msg->stop = false;
 916                         f7_msg->count = 1;
 917                         cr2 &= ~STM32F7_I2C_CR2_RD_WRN;
 918                 } else {
 919                         f7_msg->stop = true;
 920                         if (data->block[0] > I2C_SMBUS_BLOCK_MAX ||
 921                             !data->block[0]) {
 922                                 dev_err(dev, "Invalid block write size %d\n",
 923                                         data->block[0]);
 924                                 return -EINVAL;
 925                         }
 926                         f7_msg->count = data->block[0] + 2;
 927                         for (i = 1; i < f7_msg->count; i++)
 928                                 f7_msg->smbus_buf[i] = data->block[i - 1];
 929                 }
 930                 break;
 931         case I2C_SMBUS_PROC_CALL:
 932                 f7_msg->stop = false;
 933                 f7_msg->count = 3;
 934                 f7_msg->smbus_buf[1] = data->word & 0xff;
 935                 f7_msg->smbus_buf[2] = data->word >> 8;
 936                 cr2 &= ~STM32F7_I2C_CR2_RD_WRN;
 937                 f7_msg->read_write = I2C_SMBUS_READ;
 938                 break;
 939         case I2C_SMBUS_BLOCK_PROC_CALL:
 940                 f7_msg->stop = false;
 941                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX - 1) {
 942                         dev_err(dev, "Invalid block write size %d\n",
 943                                 data->block[0]);
 944                         return -EINVAL;
 945                 }
 946                 f7_msg->count = data->block[0] + 2;
 947                 for (i = 1; i < f7_msg->count; i++)
 948                         f7_msg->smbus_buf[i] = data->block[i - 1];
 949                 cr2 &= ~STM32F7_I2C_CR2_RD_WRN;
 950                 f7_msg->read_write = I2C_SMBUS_READ;
 951                 break;
 952         default:
 953                 dev_err(dev, "Unsupported smbus protocol %d\n", f7_msg->size);
 954                 return -EOPNOTSUPP;
 955         }
 956
 957         f7_msg->buf = f7_msg->smbus_buf;
 958
 959         /* Configure PEC */
 960         if ((flags & I2C_CLIENT_PEC) && f7_msg->size != I2C_SMBUS_QUICK) {
 961                 cr1 |= STM32F7_I2C_CR1_PECEN;
 962                 cr2 |= STM32F7_I2C_CR2_PECBYTE;
 963                 if (!f7_msg->read_write)
 964                         f7_msg->count++;
 965         } else {
 966                 cr1 &= ~STM32F7_I2C_CR1_PECEN;
 967                 cr2 &= ~STM32F7_I2C_CR2_PECBYTE;
 968         }
 969
 970         /* Set number of bytes to be transferred */
 971         cr2 &= ~(STM32F7_I2C_CR2_NBYTES_MASK | STM32F7_I2C_CR2_RELOAD);
 972         cr2 |= STM32F7_I2C_CR2_NBYTES(f7_msg->count);
 973
 974         /* Enable NACK, STOP, error and transfer complete interrupts */
 975         cr1 |= STM32F7_I2C_CR1_ERRIE | STM32F7_I2C_CR1_TCIE |
 976                 STM32F7_I2C_CR1_STOPIE | STM32F7_I2C_CR1_NACKIE;
 977
 978         /* Clear DMA req and TX/RX interrupt */
 979         cr1 &= ~(STM32F7_I2C_CR1_RXIE | STM32F7_I2C_CR1_TXIE |
 980                         STM32F7_I2C_CR1_RXDMAEN | STM32F7_I2C_CR1_TXDMAEN);
 981
 982         /* Configure DMA or enable RX/TX interrupt */
 983         i2c_dev->use_dma = false;
 984         if (i2c_dev->dma && f7_msg->count >= STM32F7_I2C_DMA_LEN_MIN) {
 985                 ret = stm32_i2c_prep_dma_xfer(i2c_dev->dev, i2c_dev->dma,
 986                                               cr2 & STM32F7_I2C_CR2_RD_WRN,
 987                                               f7_msg->count, f7_msg->buf,
 988                                               stm32f7_i2c_dma_callback,
 989                                               i2c_dev);
 990                 if (!ret)
 991                         i2c_dev->use_dma = true;
 992                 else
 993                         dev_warn(i2c_dev->dev, "can't use DMA\n");
 994         }
 995
 996         if (!i2c_dev->use_dma) {
 997                 if (cr2 & STM32F7_I2C_CR2_RD_WRN)
 998                         cr1 |= STM32F7_I2C_CR1_RXIE;
 999                 else
1000                         cr1 |= STM32F7_I2C_CR1_TXIE;
1001         } else {
1002                 if (cr2 & STM32F7_I2C_CR2_RD_WRN)
1003                         cr1 |= STM32F7_I2C_CR1_RXDMAEN;
1004                 else
1005                         cr1 |= STM32F7_I2C_CR1_TXDMAEN;
1006         }
1007
1008         /* Set Start bit */
1009         cr2 |= STM32F7_I2C_CR2_START;
1010
1011         i2c_dev->master_mode = true;
1012
1013         /* Write configurations registers */
1014         writel_relaxed(cr1, base + STM32F7_I2C_CR1);
1015         writel_relaxed(cr2, base + STM32F7_I2C_CR2);
1016
1017         return 0;
1018 }
1019
1020 static void stm32f7_i2c_smbus_rep_start(struct stm32f7_i2c_dev *i2c_dev)
1021 {
1022         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
1023         void __iomem *base = i2c_dev->base;
1024         u32 cr1, cr2;
1025         int ret;
1026
1027         cr2 = readl_relaxed(base + STM32F7_I2C_CR2);
1028         cr1 = readl_relaxed(base + STM32F7_I2C_CR1);
1029
1030         /* Set transfer direction */
1031         cr2 |= STM32F7_I2C_CR2_RD_WRN;
1032
1033         switch (f7_msg->size) {
1034         case I2C_SMBUS_BYTE_DATA:
1035                 f7_msg->count = 1;
1036                 break;
1037         case I2C_SMBUS_WORD_DATA:
1038         case I2C_SMBUS_PROC_CALL:
1039                 f7_msg->count = 2;
1040                 break;
1041         case I2C_SMBUS_BLOCK_DATA:
1042         case I2C_SMBUS_BLOCK_PROC_CALL:
1043                 f7_msg->count = 1;
1044                 cr2 |= STM32F7_I2C_CR2_RELOAD;
1045                 break;
1046         }
1047
1048         f7_msg->buf = f7_msg->smbus_buf;
1049         f7_msg->stop = true;
1050
1051         /* Add one byte for PEC if needed */
1052         if (cr1 & STM32F7_I2C_CR1_PECEN)
1053                 f7_msg->count++;
1054
1055         /* Set number of bytes to be transferred */
1056         cr2 &= ~(STM32F7_I2C_CR2_NBYTES_MASK);
1057         cr2 |= STM32F7_I2C_CR2_NBYTES(f7_msg->count);
1058
1059         /*
1060          * Configure RX/TX interrupt:
1061          */
1062         cr1 &= ~(STM32F7_I2C_CR1_RXIE | STM32F7_I2C_CR1_TXIE);
1063         cr1 |= STM32F7_I2C_CR1_RXIE;
1064
1065         /*
1066          * Configure DMA or enable RX/TX interrupt:
1067          * For I2C_SMBUS_BLOCK_DATA and I2C_SMBUS_BLOCK_PROC_CALL we don't use
1068          * dma as we don't know in advance how many data will be received
1069          */
1070         cr1 &= ~(STM32F7_I2C_CR1_RXIE | STM32F7_I2C_CR1_TXIE |
1071                  STM32F7_I2C_CR1_RXDMAEN | STM32F7_I2C_CR1_TXDMAEN);
1072
1073         i2c_dev->use_dma = false;
1074         if (i2c_dev->dma && f7_msg->count >= STM32F7_I2C_DMA_LEN_MIN &&
1075             f7_msg->size != I2C_SMBUS_BLOCK_DATA &&
1076             f7_msg->size != I2C_SMBUS_BLOCK_PROC_CALL) {
1077                 ret = stm32_i2c_prep_dma_xfer(i2c_dev->dev, i2c_dev->dma,
1078                                               cr2 & STM32F7_I2C_CR2_RD_WRN,
1079                                               f7_msg->count, f7_msg->buf,
1080                                               stm32f7_i2c_dma_callback,
1081                                               i2c_dev);
1082
1083                 if (!ret)
1084                         i2c_dev->use_dma = true;
1085                 else
1086                         dev_warn(i2c_dev->dev, "can't use DMA\n");
1087         }
1088
1089         if (!i2c_dev->use_dma)
1090                 cr1 |= STM32F7_I2C_CR1_RXIE;
1091         else
1092                 cr1 |= STM32F7_I2C_CR1_RXDMAEN;
1093
1094         /* Configure Repeated Start */
1095         cr2 |= STM32F7_I2C_CR2_START;
1096
1097         /* Write configurations registers */
1098         writel_relaxed(cr1, base + STM32F7_I2C_CR1);
1099         writel_relaxed(cr2, base + STM32F7_I2C_CR2);
1100 }
1101
1102 static int stm32f7_i2c_smbus_check_pec(struct stm32f7_i2c_dev *i2c_dev)
1103 {
1104         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
1105         u8 count, internal_pec, received_pec;
1106
1107         internal_pec = readl_relaxed(i2c_dev->base + STM32F7_I2C_PECR);
1108
1109         switch (f7_msg->size) {
1110         case I2C_SMBUS_BYTE:
1111         case I2C_SMBUS_BYTE_DATA:
1112                 received_pec = f7_msg->smbus_buf[1];
1113                 break;
1114         case I2C_SMBUS_WORD_DATA:
1115         case I2C_SMBUS_PROC_CALL:
1116                 received_pec = f7_msg->smbus_buf[2];
1117                 break;
1118         case I2C_SMBUS_BLOCK_DATA:
1119         case I2C_SMBUS_BLOCK_PROC_CALL:
1120                 count = f7_msg->smbus_buf[0];
1121                 received_pec = f7_msg->smbus_buf[count];
1122                 break;
1123         default:
1124                 dev_err(i2c_dev->dev, "Unsupported smbus protocol for PEC\n");
1125                 return -EINVAL;
1126         }
1127
1128         if (internal_pec != received_pec) {
1129                 dev_err(i2c_dev->dev, "Bad PEC 0x%02x vs. 0x%02x\n",
1130                         internal_pec, received_pec);
1131                 return -EBADMSG;
1132         }
1133
1134         return 0;
1135 }
1136
1137 static bool stm32f7_i2c_is_addr_match(struct i2c_client *slave, u32 addcode)
1138 {
1139         u32 addr;
1140
1141         if (!slave)
1142                 return false;
1143
1144         if (slave->flags & I2C_CLIENT_TEN) {
1145                 /*
1146                  * For 10-bit addr, addcode = 11110XY with
1147                  * X = Bit 9 of slave address
1148                  * Y = Bit 8 of slave address
1149                  */
1150                 addr = slave->addr >> 8;
1151                 addr |= 0x78;
1152                 if (addr == addcode)
1153                         return true;
1154         } else {
1155                 addr = slave->addr & 0x7f;
1156                 if (addr == addcode)
1157                         return true;
1158         }
1159
1160         return false;
1161 }
1162
1163 static void stm32f7_i2c_slave_start(struct stm32f7_i2c_dev *i2c_dev)
1164 {
1165         struct i2c_client *slave = i2c_dev->slave_running;
1166         void __iomem *base = i2c_dev->base;
1167         u32 mask;
1168         u8 value = 0;
1169
1170         if (i2c_dev->slave_dir) {
1171                 /* Notify i2c slave that new read transfer is starting */
1172                 i2c_slave_event(slave, I2C_SLAVE_READ_REQUESTED, &value);
1173
1174                 /*
1175                  * Disable slave TX config in case of I2C combined message
1176                  * (I2C Write followed by I2C Read)
1177                  */
1178                 mask = STM32F7_I2C_CR2_RELOAD;
1179                 stm32f7_i2c_clr_bits(base + STM32F7_I2C_CR2, mask);
1180                 mask = STM32F7_I2C_CR1_SBC | STM32F7_I2C_CR1_RXIE |
1181                        STM32F7_I2C_CR1_TCIE;
1182                 stm32f7_i2c_clr_bits(base + STM32F7_I2C_CR1, mask);
1183
1184                 /* Enable TX empty, STOP, NACK interrupts */
1185                 mask =  STM32F7_I2C_CR1_STOPIE | STM32F7_I2C_CR1_NACKIE |
1186                         STM32F7_I2C_CR1_TXIE;
1187                 stm32f7_i2c_set_bits(base + STM32F7_I2C_CR1, mask);
1188
1189                 /* Write 1st data byte */
1190                 writel_relaxed(value, base + STM32F7_I2C_TXDR);
1191         } else {
1192                 /* Notify i2c slave that new write transfer is starting */
1193                 i2c_slave_event(slave, I2C_SLAVE_WRITE_REQUESTED, &value);
1194
1195                 /* Set reload mode to be able to ACK/NACK each received byte */
1196                 mask = STM32F7_I2C_CR2_RELOAD;
1197                 stm32f7_i2c_set_bits(base + STM32F7_I2C_CR2, mask);
1198
1199                 /*
1200                  * Set STOP, NACK, RX empty and transfer complete interrupts.*
1201                  * Set Slave Byte Control to be able to ACK/NACK each data
1202                  * byte received
1203                  */
1204                 mask =  STM32F7_I2C_CR1_STOPIE | STM32F7_I2C_CR1_NACKIE |
1205                         STM32F7_I2C_CR1_SBC | STM32F7_I2C_CR1_RXIE |
1206                         STM32F7_I2C_CR1_TCIE;
1207                 stm32f7_i2c_set_bits(base + STM32F7_I2C_CR1, mask);
1208         }
1209 }
1210
1211 static void stm32f7_i2c_slave_addr(struct stm32f7_i2c_dev *i2c_dev)
1212 {
1213         void __iomem *base = i2c_dev->base;
1214         u32 isr, addcode, dir, mask;
1215         int i;
1216
1217         isr = readl_relaxed(i2c_dev->base + STM32F7_I2C_ISR);
1218         addcode = STM32F7_I2C_ISR_ADDCODE_GET(isr);
1219         dir = isr & STM32F7_I2C_ISR_DIR;
1220
1221         for (i = 0; i < STM32F7_I2C_MAX_SLAVE; i++) {
1222                 if (stm32f7_i2c_is_addr_match(i2c_dev->slave[i], addcode)) {
1223                         i2c_dev->slave_running = i2c_dev->slave[i];
1224                         i2c_dev->slave_dir = dir;
1225
1226                         /* Start I2C slave processing */
1227                         stm32f7_i2c_slave_start(i2c_dev);
1228
1229                         /* Clear ADDR flag */
1230                         mask = STM32F7_I2C_ICR_ADDRCF;
1231                         writel_relaxed(mask, base + STM32F7_I2C_ICR);
1232                         break;
1233                 }
1234         }
1235 }
1236
1237 static int stm32f7_i2c_get_slave_id(struct stm32f7_i2c_dev *i2c_dev,
1238                                     struct i2c_client *slave, int *id)
1239 {
1240         int i;
1241
1242         for (i = 0; i < STM32F7_I2C_MAX_SLAVE; i++) {
1243                 if (i2c_dev->slave[i] == slave) {
1244                         *id = i;
1245                         return 0;
1246                 }
1247         }
1248
1249         dev_err(i2c_dev->dev, "Slave 0x%x not registered\n", slave->addr);
1250
1251         return -ENODEV;
1252 }
1253
1254 static int stm32f7_i2c_get_free_slave_id(struct stm32f7_i2c_dev *i2c_dev,
1255                                          struct i2c_client *slave, int *id)
1256 {
1257         struct device *dev = i2c_dev->dev;
1258         int i;
1259
1260         /*
1261          * slave[0] supports 7-bit and 10-bit slave address
1262          * slave[1] supports 7-bit slave address only
1263          */
1264         for (i = STM32F7_I2C_MAX_SLAVE - 1; i >= 0; i--) {
1265                 if (i == 1 && (slave->flags & I2C_CLIENT_TEN))
1266                         continue;
1267                 if (!i2c_dev->slave[i]) {
1268                         *id = i;
1269                         return 0;
1270                 }
1271         }
1272
1273         dev_err(dev, "Slave 0x%x could not be registered\n", slave->addr);
1274
1275         return -EINVAL;
1276 }
1277
1278 static bool stm32f7_i2c_is_slave_registered(struct stm32f7_i2c_dev *i2c_dev)
1279 {
1280         int i;
1281
1282         for (i = 0; i < STM32F7_I2C_MAX_SLAVE; i++) {
1283                 if (i2c_dev->slave[i])
1284                         return true;
1285         }
1286
1287         return false;
1288 }
1289
1290 static bool stm32f7_i2c_is_slave_busy(struct stm32f7_i2c_dev *i2c_dev)
1291 {
1292         int i, busy;
1293
1294         busy = 0;
1295         for (i = 0; i < STM32F7_I2C_MAX_SLAVE; i++) {
1296                 if (i2c_dev->slave[i])
1297                         busy++;
1298         }
1299
1300         return i == busy;
1301 }
1302
1303 static irqreturn_t stm32f7_i2c_slave_isr_event(struct stm32f7_i2c_dev *i2c_dev)
1304 {
1305         void __iomem *base = i2c_dev->base;
1306         u32 cr2, status, mask;
1307         u8 val;
1308         int ret;
1309
1310         status = readl_relaxed(i2c_dev->base + STM32F7_I2C_ISR);
1311
1312         /* Slave transmitter mode */
1313         if (status & STM32F7_I2C_ISR_TXIS) {
1314                 i2c_slave_event(i2c_dev->slave_running,
1315                                 I2C_SLAVE_READ_PROCESSED,
1316                                 &val);
1317
1318                 /* Write data byte */
1319                 writel_relaxed(val, base + STM32F7_I2C_TXDR);
1320         }
1321
1322         /* Transfer Complete Reload for Slave receiver mode */
1323         if (status & STM32F7_I2C_ISR_TCR || status & STM32F7_I2C_ISR_RXNE) {
1324                 /*
1325                  * Read data byte then set NBYTES to receive next byte or NACK
1326                  * the current received byte
1327                  */
1328                 val = readb_relaxed(i2c_dev->base + STM32F7_I2C_RXDR);
1329                 ret = i2c_slave_event(i2c_dev->slave_running,
1330                                       I2C_SLAVE_WRITE_RECEIVED,
1331                                       &val);
1332                 if (!ret) {
1333                         cr2 = readl_relaxed(i2c_dev->base + STM32F7_I2C_CR2);
1334                         cr2 |= STM32F7_I2C_CR2_NBYTES(1);
1335                         writel_relaxed(cr2, i2c_dev->base + STM32F7_I2C_CR2);
1336                 } else {
1337                         mask = STM32F7_I2C_CR2_NACK;
1338                         stm32f7_i2c_set_bits(base + STM32F7_I2C_CR2, mask);
1339                 }
1340         }
1341
1342         /* NACK received */
1343         if (status & STM32F7_I2C_ISR_NACKF) {
1344                 dev_dbg(i2c_dev->dev, "<%s>: Receive NACK\n", __func__);
1345                 writel_relaxed(STM32F7_I2C_ICR_NACKCF, base + STM32F7_I2C_ICR);
1346         }
1347
1348         /* STOP received */
1349         if (status & STM32F7_I2C_ISR_STOPF) {
1350                 /* Disable interrupts */
1351                 stm32f7_i2c_disable_irq(i2c_dev, STM32F7_I2C_XFER_IRQ_MASK);
1352
1353                 if (i2c_dev->slave_dir) {
1354                         /*
1355                          * Flush TX buffer in order to not used the byte in
1356                          * TXDR for the next transfer
1357                          */
1358                         mask = STM32F7_I2C_ISR_TXE;
1359                         stm32f7_i2c_set_bits(base + STM32F7_I2C_ISR, mask);
1360                 }
1361
1362                 /* Clear STOP flag */
1363                 writel_relaxed(STM32F7_I2C_ICR_STOPCF, base + STM32F7_I2C_ICR);
1364
1365                 /* Notify i2c slave that a STOP flag has been detected */
1366                 i2c_slave_event(i2c_dev->slave_running, I2C_SLAVE_STOP, &val);
1367
1368                 i2c_dev->slave_running = NULL;
1369         }
1370
1371         /* Address match received */
1372         if (status & STM32F7_I2C_ISR_ADDR)
1373                 stm32f7_i2c_slave_addr(i2c_dev);
1374
1375         return IRQ_HANDLED;
1376 }
1377
1378 static irqreturn_t stm32f7_i2c_isr_event(int irq, void *data)
1379 {
1380         struct stm32f7_i2c_dev *i2c_dev = data;
1381         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
1382         struct stm32_i2c_dma *dma = i2c_dev->dma;
1383         void __iomem *base = i2c_dev->base;
1384         u32 status, mask;
1385         int ret = IRQ_HANDLED;
1386
1387         /* Check if the interrupt if for a slave device */
1388         if (!i2c_dev->master_mode) {
1389                 ret = stm32f7_i2c_slave_isr_event(i2c_dev);
1390                 return ret;
1391         }
1392
1393         status = readl_relaxed(i2c_dev->base + STM32F7_I2C_ISR);
1394
1395         /* Tx empty */
1396         if (status & STM32F7_I2C_ISR_TXIS)
1397                 stm32f7_i2c_write_tx_data(i2c_dev);
1398
1399         /* RX not empty */
1400         if (status & STM32F7_I2C_ISR_RXNE)
1401                 stm32f7_i2c_read_rx_data(i2c_dev);
1402
1403         /* NACK received */
1404         if (status & STM32F7_I2C_ISR_NACKF) {
1405                 dev_dbg(i2c_dev->dev, "<%s>: Receive NACK\n", __func__);
1406                 writel_relaxed(STM32F7_I2C_ICR_NACKCF, base + STM32F7_I2C_ICR);
1407                 if (i2c_dev->use_dma) {
1408                         stm32f7_i2c_disable_dma_req(i2c_dev);
1409                         dmaengine_terminate_all(dma->chan_using);
1410                 }
1411                 f7_msg->result = -ENXIO;
1412         }
1413
1414         /* STOP detection flag */
1415         if (status & STM32F7_I2C_ISR_STOPF) {
1416                 /* Disable interrupts */
1417                 if (stm32f7_i2c_is_slave_registered(i2c_dev))
1418                         mask = STM32F7_I2C_XFER_IRQ_MASK;
1419                 else
1420                         mask = STM32F7_I2C_ALL_IRQ_MASK;
1421                 stm32f7_i2c_disable_irq(i2c_dev, mask);
1422
1423                 /* Clear STOP flag */
1424                 writel_relaxed(STM32F7_I2C_ICR_STOPCF, base + STM32F7_I2C_ICR);
1425
1426                 if (i2c_dev->use_dma && !f7_msg->result) {
1427                         ret = IRQ_WAKE_THREAD;
1428                 } else {
1429                         i2c_dev->master_mode = false;
1430                         complete(&i2c_dev->complete);
1431                 }
1432         }
1433
1434         /* Transfer complete */
1435         if (status & STM32F7_I2C_ISR_TC) {
1436                 if (f7_msg->stop) {
1437                         mask = STM32F7_I2C_CR2_STOP;
1438                         stm32f7_i2c_set_bits(base + STM32F7_I2C_CR2, mask);
1439                 } else if (i2c_dev->use_dma && !f7_msg->result) {
1440                         ret = IRQ_WAKE_THREAD;
1441                 } else if (f7_msg->smbus) {
1442                         stm32f7_i2c_smbus_rep_start(i2c_dev);
1443                 } else {
1444                         i2c_dev->msg_id++;
1445                         i2c_dev->msg++;
1446                         stm32f7_i2c_xfer_msg(i2c_dev, i2c_dev->msg);
1447                 }
1448         }
1449
1450         if (status & STM32F7_I2C_ISR_TCR) {
1451                 if (f7_msg->smbus)
1452                         stm32f7_i2c_smbus_reload(i2c_dev);
1453                 else
1454                         stm32f7_i2c_reload(i2c_dev);
1455         }
1456
1457         return ret;
1458 }
1459
1460 static irqreturn_t stm32f7_i2c_isr_event_thread(int irq, void *data)
1461 {
1462         struct stm32f7_i2c_dev *i2c_dev = data;
1463         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
1464         struct stm32_i2c_dma *dma = i2c_dev->dma;
1465         u32 status;
1466         int ret;
1467
1468         /*
1469          * Wait for dma transfer completion before sending next message or
1470          * notity the end of xfer to the client
1471          */
1472         ret = wait_for_completion_timeout(&i2c_dev->dma->dma_complete, HZ);
1473         if (!ret) {
1474                 dev_dbg(i2c_dev->dev, "<%s>: Timed out\n", __func__);
1475                 stm32f7_i2c_disable_dma_req(i2c_dev);
1476                 dmaengine_terminate_all(dma->chan_using);
1477                 f7_msg->result = -ETIMEDOUT;
1478         }
1479
1480         status = readl_relaxed(i2c_dev->base + STM32F7_I2C_ISR);
1481
1482         if (status & STM32F7_I2C_ISR_TC) {
1483                 if (f7_msg->smbus) {
1484                         stm32f7_i2c_smbus_rep_start(i2c_dev);
1485                 } else {
1486                         i2c_dev->msg_id++;
1487                         i2c_dev->msg++;
1488                         stm32f7_i2c_xfer_msg(i2c_dev, i2c_dev->msg);
1489                 }
1490         } else {
1491                 i2c_dev->master_mode = false;
1492                 complete(&i2c_dev->complete);
1493         }
1494
1495         return IRQ_HANDLED;
1496 }
1497
1498 static irqreturn_t stm32f7_i2c_isr_error(int irq, void *data)
1499 {
1500         struct stm32f7_i2c_dev *i2c_dev = data;
1501         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
1502         void __iomem *base = i2c_dev->base;
1503         struct device *dev = i2c_dev->dev;
1504         struct stm32_i2c_dma *dma = i2c_dev->dma;
1505         u32 status;
1506
1507         status = readl_relaxed(i2c_dev->base + STM32F7_I2C_ISR);
1508
1509         /* Bus error */
1510         if (status & STM32F7_I2C_ISR_BERR) {
1511                 dev_err(dev, "<%s>: Bus error\n", __func__);
1512                 writel_relaxed(STM32F7_I2C_ICR_BERRCF, base + STM32F7_I2C_ICR);
1513                 stm32f7_i2c_release_bus(&i2c_dev->adap);
1514                 f7_msg->result = -EIO;
1515         }
1516
1517         /* Arbitration loss */
1518         if (status & STM32F7_I2C_ISR_ARLO) {
1519                 dev_dbg(dev, "<%s>: Arbitration loss\n", __func__);
1520                 writel_relaxed(STM32F7_I2C_ICR_ARLOCF, base + STM32F7_I2C_ICR);
1521                 f7_msg->result = -EAGAIN;
1522         }
1523
1524         if (status & STM32F7_I2C_ISR_PECERR) {
1525                 dev_err(dev, "<%s>: PEC error in reception\n", __func__);
1526                 writel_relaxed(STM32F7_I2C_ICR_PECCF, base + STM32F7_I2C_ICR);
1527                 f7_msg->result = -EINVAL;
1528         }
1529
1530         if (!i2c_dev->slave_running) {
1531                 u32 mask;
1532                 /* Disable interrupts */
1533                 if (stm32f7_i2c_is_slave_registered(i2c_dev))
1534                         mask = STM32F7_I2C_XFER_IRQ_MASK;
1535                 else
1536                         mask = STM32F7_I2C_ALL_IRQ_MASK;
1537                 stm32f7_i2c_disable_irq(i2c_dev, mask);
1538         }
1539
1540         /* Disable dma */
1541         if (i2c_dev->use_dma) {
1542                 stm32f7_i2c_disable_dma_req(i2c_dev);
1543                 dmaengine_terminate_all(dma->chan_using);
1544         }
1545
1546         i2c_dev->master_mode = false;
1547         complete(&i2c_dev->complete);
1548
1549         return IRQ_HANDLED;
1550 }
1551
1552 static int stm32f7_i2c_xfer(struct i2c_adapter *i2c_adap,
1553                             struct i2c_msg msgs[], int num)
1554 {
1555         struct stm32f7_i2c_dev *i2c_dev = i2c_get_adapdata(i2c_adap);
1556         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
1557         struct stm32_i2c_dma *dma = i2c_dev->dma;
1558         unsigned long time_left;
1559         int ret;
1560
1561         i2c_dev->msg = msgs;
1562         i2c_dev->msg_num = num;
1563         i2c_dev->msg_id = 0;
1564         f7_msg->smbus = false;
1565
1566         ret = clk_enable(i2c_dev->clk);
1567         if (ret) {
1568                 dev_err(i2c_dev->dev, "Failed to enable clock\n");
1569                 return ret;
1570         }
1571
1572         ret = stm32f7_i2c_wait_free_bus(i2c_dev);
1573         if (ret)
1574                 goto clk_free;
1575
1576         stm32f7_i2c_xfer_msg(i2c_dev, msgs);
1577
1578         time_left = wait_for_completion_timeout(&i2c_dev->complete,
1579                                                 i2c_dev->adap.timeout);
1580         ret = f7_msg->result;
1581
1582         if (!time_left) {
1583                 dev_dbg(i2c_dev->dev, "Access to slave 0x%x timed out\n",
1584                         i2c_dev->msg->addr);
1585                 if (i2c_dev->use_dma)
1586                         dmaengine_terminate_all(dma->chan_using);
1587                 stm32f7_i2c_wait_free_bus(i2c_dev);
1588                 ret = -ETIMEDOUT;
1589         }
1590
1591 clk_free:
1592         clk_disable(i2c_dev->clk);
1593
1594         return (ret < 0) ? ret : num;
1595 }
1596
1597 static int stm32f7_i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
1598                                   unsigned short flags, char read_write,
1599                                   u8 command, int size,
1600                                   union i2c_smbus_data *data)
1601 {
1602         struct stm32f7_i2c_dev *i2c_dev = i2c_get_adapdata(adapter);
1603         struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
1604         struct stm32_i2c_dma *dma = i2c_dev->dma;
1605         struct device *dev = i2c_dev->dev;
1606         unsigned long timeout;
1607         int i, ret;
1608
1609         f7_msg->addr = addr;
1610         f7_msg->size = size;
1611         f7_msg->read_write = read_write;
1612         f7_msg->smbus = true;
1613
1614         ret = clk_enable(i2c_dev->clk);
1615         if (ret) {
1616                 dev_err(i2c_dev->dev, "Failed to enable clock\n");
1617                 return ret;
1618         }
1619
1620         ret = stm32f7_i2c_wait_free_bus(i2c_dev);
1621         if (ret)
1622                 goto clk_free;
1623
1624         ret = stm32f7_i2c_smbus_xfer_msg(i2c_dev, flags, command, data);
1625         if (ret)
1626                 goto clk_free;
1627
1628         timeout = wait_for_completion_timeout(&i2c_dev->complete,
1629                                               i2c_dev->adap.timeout);
1630         ret = f7_msg->result;
1631         if (ret)
1632                 goto clk_free;
1633
1634         if (!timeout) {
1635                 dev_dbg(dev, "Access to slave 0x%x timed out\n", f7_msg->addr);
1636                 if (i2c_dev->use_dma)
1637                         dmaengine_terminate_all(dma->chan_using);
1638                 stm32f7_i2c_wait_free_bus(i2c_dev);
1639                 ret = -ETIMEDOUT;
1640                 goto clk_free;
1641         }
1642
1643         /* Check PEC */
1644         if ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK && read_write) {
1645                 ret = stm32f7_i2c_smbus_check_pec(i2c_dev);
1646                 if (ret)
1647                         goto clk_free;
1648         }
1649
1650         if (read_write && size != I2C_SMBUS_QUICK) {
1651                 switch (size) {
1652                 case I2C_SMBUS_BYTE:
1653                 case I2C_SMBUS_BYTE_DATA:
1654                         data->byte = f7_msg->smbus_buf[0];
1655                 break;
1656                 case I2C_SMBUS_WORD_DATA:
1657                 case I2C_SMBUS_PROC_CALL:
1658                         data->word = f7_msg->smbus_buf[0] |
1659                                 (f7_msg->smbus_buf[1] << 8);
1660                 break;
1661                 case I2C_SMBUS_BLOCK_DATA:
1662                 case I2C_SMBUS_BLOCK_PROC_CALL:
1663                 for (i = 0; i <= f7_msg->smbus_buf[0]; i++)
1664                         data->block[i] = f7_msg->smbus_buf[i];
1665                 break;
1666                 default:
1667                         dev_err(dev, "Unsupported smbus transaction\n");
1668                         ret = -EINVAL;
1669                 }
1670         }
1671
1672 clk_free:
1673         clk_disable(i2c_dev->clk);
1674         return ret;
1675 }
1676
1677 static int stm32f7_i2c_reg_slave(struct i2c_client *slave)
1678 {
1679         struct stm32f7_i2c_dev *i2c_dev = i2c_get_adapdata(slave->adapter);
1680         void __iomem *base = i2c_dev->base;
1681         struct device *dev = i2c_dev->dev;
1682         u32 oar1, oar2, mask;
1683         int id, ret;
1684
1685         if (slave->flags & I2C_CLIENT_PEC) {
1686                 dev_err(dev, "SMBus PEC not supported in slave mode\n");
1687                 return -EINVAL;
1688         }
1689
1690         if (stm32f7_i2c_is_slave_busy(i2c_dev)) {
1691                 dev_err(dev, "Too much slave registered\n");
1692                 return -EBUSY;
1693         }
1694
1695         ret = stm32f7_i2c_get_free_slave_id(i2c_dev, slave, &id);
1696         if (ret)
1697                 return ret;
1698
1699         if (!(stm32f7_i2c_is_slave_registered(i2c_dev))) {
1700                 ret = clk_enable(i2c_dev->clk);
1701                 if (ret) {
1702                         dev_err(dev, "Failed to enable clock\n");
1703                         return ret;
1704                 }
1705         }
1706
1707         if (id == 0) {
1708                 /* Configure Own Address 1 */
1709                 oar1 = readl_relaxed(i2c_dev->base + STM32F7_I2C_OAR1);
1710                 oar1 &= ~STM32F7_I2C_OAR1_MASK;
1711                 if (slave->flags & I2C_CLIENT_TEN) {
1712                         oar1 |= STM32F7_I2C_OAR1_OA1_10(slave->addr);
1713                         oar1 |= STM32F7_I2C_OAR1_OA1MODE;
1714                 } else {
1715                         oar1 |= STM32F7_I2C_OAR1_OA1_7(slave->addr);
1716                 }
1717                 oar1 |= STM32F7_I2C_OAR1_OA1EN;
1718                 i2c_dev->slave[id] = slave;
1719                 writel_relaxed(oar1, i2c_dev->base + STM32F7_I2C_OAR1);
1720         } else if (id == 1) {
1721                 /* Configure Own Address 2 */
1722                 oar2 = readl_relaxed(i2c_dev->base + STM32F7_I2C_OAR2);
1723                 oar2 &= ~STM32F7_I2C_OAR2_MASK;
1724                 if (slave->flags & I2C_CLIENT_TEN) {
1725                         ret = -EOPNOTSUPP;
1726                         goto exit;
1727                 }
1728
1729                 oar2 |= STM32F7_I2C_OAR2_OA2_7(slave->addr);
1730                 oar2 |= STM32F7_I2C_OAR2_OA2EN;
1731                 i2c_dev->slave[id] = slave;
1732                 writel_relaxed(oar2, i2c_dev->base + STM32F7_I2C_OAR2);
1733         } else {
1734                 ret = -ENODEV;
1735                 goto exit;
1736         }
1737
1738         /* Enable ACK */
1739         stm32f7_i2c_clr_bits(base + STM32F7_I2C_CR2, STM32F7_I2C_CR2_NACK);
1740
1741         /* Enable Address match interrupt, error interrupt and enable I2C  */
1742         mask = STM32F7_I2C_CR1_ADDRIE | STM32F7_I2C_CR1_ERRIE |
1743                 STM32F7_I2C_CR1_PE;
1744         stm32f7_i2c_set_bits(base + STM32F7_I2C_CR1, mask);
1745
1746         return 0;
1747
1748 exit:
1749         if (!(stm32f7_i2c_is_slave_registered(i2c_dev)))
1750                 clk_disable(i2c_dev->clk);
1751
1752         return ret;
1753 }
1754
1755 static int stm32f7_i2c_unreg_slave(struct i2c_client *slave)
1756 {
1757         struct stm32f7_i2c_dev *i2c_dev = i2c_get_adapdata(slave->adapter);
1758         void __iomem *base = i2c_dev->base;
1759         u32 mask;
1760         int id, ret;
1761
1762         ret = stm32f7_i2c_get_slave_id(i2c_dev, slave, &id);
1763         if (ret)
1764                 return ret;
1765
1766         WARN_ON(!i2c_dev->slave[id]);
1767
1768         if (id == 0) {
1769                 mask = STM32F7_I2C_OAR1_OA1EN;
1770                 stm32f7_i2c_clr_bits(base + STM32F7_I2C_OAR1, mask);
1771         } else {
1772                 mask = STM32F7_I2C_OAR2_OA2EN;
1773                 stm32f7_i2c_clr_bits(base + STM32F7_I2C_OAR2, mask);
1774         }
1775
1776         i2c_dev->slave[id] = NULL;
1777
1778         if (!(stm32f7_i2c_is_slave_registered(i2c_dev))) {
1779                 stm32f7_i2c_disable_irq(i2c_dev, STM32F7_I2C_ALL_IRQ_MASK);
1780                 clk_disable(i2c_dev->clk);
1781         }
1782
1783         return 0;
1784 }
1785
1786 static u32 stm32f7_i2c_func(struct i2c_adapter *adap)
1787 {
1788         return I2C_FUNC_I2C | I2C_FUNC_10BIT_ADDR | I2C_FUNC_SLAVE |
1789                 I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
1790                 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
1791                 I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
1792                 I2C_FUNC_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_PEC;
1793 }
1794
1795 static struct i2c_algorithm stm32f7_i2c_algo = {
1796         .master_xfer = stm32f7_i2c_xfer,
1797         .smbus_xfer = stm32f7_i2c_smbus_xfer,
1798         .functionality = stm32f7_i2c_func,
1799         .reg_slave = stm32f7_i2c_reg_slave,
1800         .unreg_slave = stm32f7_i2c_unreg_slave,
1801 };
1802
1803 static int stm32f7_i2c_probe(struct platform_device *pdev)
1804 {
1805         struct stm32f7_i2c_dev *i2c_dev;
1806         const struct stm32f7_i2c_setup *setup;
1807         struct resource *res;
1808         u32 clk_rate, rise_time, fall_time;
1809         struct i2c_adapter *adap;
1810         struct reset_control *rst;
1811         dma_addr_t phy_addr;
1812         int irq_error, irq_event, ret;
1813
1814         i2c_dev = devm_kzalloc(&pdev->dev, sizeof(*i2c_dev), GFP_KERNEL);
1815         if (!i2c_dev)
1816                 return -ENOMEM;
1817
1818         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1819         i2c_dev->base = devm_ioremap_resource(&pdev->dev, res);
1820         if (IS_ERR(i2c_dev->base))
1821                 return PTR_ERR(i2c_dev->base);
1822         phy_addr = (dma_addr_t)res->start;
1823
1824         irq_event = platform_get_irq(pdev, 0);
1825         if (irq_event <= 0) {
1826                 if (irq_event != -EPROBE_DEFER)
1827                         dev_err(&pdev->dev, "Failed to get IRQ event: %d\n",
1828                                 irq_event);
1829                 return irq_event ? : -ENOENT;
1830         }
1831
1832         irq_error = platform_get_irq(pdev, 1);
1833         if (irq_error <= 0) {
1834                 if (irq_error != -EPROBE_DEFER)
1835                         dev_err(&pdev->dev, "Failed to get IRQ error: %d\n",
1836                                 irq_error);
1837                 return irq_error ? : -ENOENT;
1838         }
1839
1840         i2c_dev->clk = devm_clk_get(&pdev->dev, NULL);
1841         if (IS_ERR(i2c_dev->clk)) {
1842                 dev_err(&pdev->dev, "Error: Missing controller clock\n");
1843                 return PTR_ERR(i2c_dev->clk);
1844         }
1845         ret = clk_prepare_enable(i2c_dev->clk);
1846         if (ret) {
1847                 dev_err(&pdev->dev, "Failed to prepare_enable clock\n");
1848                 return ret;
1849         }
1850
1851         i2c_dev->speed = STM32_I2C_SPEED_STANDARD;
1852         ret = device_property_read_u32(&pdev->dev, "clock-frequency",
1853                                        &clk_rate);
1854         if (!ret && clk_rate >= 1000000)
1855                 i2c_dev->speed = STM32_I2C_SPEED_FAST_PLUS;
1856         else if (!ret && clk_rate >= 400000)
1857                 i2c_dev->speed = STM32_I2C_SPEED_FAST;
1858         else if (!ret && clk_rate >= 100000)
1859                 i2c_dev->speed = STM32_I2C_SPEED_STANDARD;
1860
1861         rst = devm_reset_control_get(&pdev->dev, NULL);
1862         if (IS_ERR(rst)) {
1863                 dev_err(&pdev->dev, "Error: Missing controller reset\n");
1864                 ret = PTR_ERR(rst);
1865                 goto clk_free;
1866         }
1867         reset_control_assert(rst);
1868         udelay(2);
1869         reset_control_deassert(rst);
1870
1871         i2c_dev->dev = &pdev->dev;
1872
1873         ret = devm_request_threaded_irq(&pdev->dev, irq_event,
1874                                         stm32f7_i2c_isr_event,
1875                                         stm32f7_i2c_isr_event_thread,
1876                                         IRQF_ONESHOT,
1877                                         pdev->name, i2c_dev);
1878         if (ret) {
1879                 dev_err(&pdev->dev, "Failed to request irq event %i\n",
1880                         irq_event);
1881                 goto clk_free;
1882         }
1883
1884         ret = devm_request_irq(&pdev->dev, irq_error, stm32f7_i2c_isr_error, 0,
1885                                pdev->name, i2c_dev);
1886         if (ret) {
1887                 dev_err(&pdev->dev, "Failed to request irq error %i\n",
1888                         irq_error);
1889                 goto clk_free;
1890         }
1891
1892         setup = of_device_get_match_data(&pdev->dev);
1893         if (!setup) {
1894                 dev_err(&pdev->dev, "Can't get device data\n");
1895                 ret = -ENODEV;
1896                 goto clk_free;
1897         }
1898         i2c_dev->setup = *setup;
1899
1900         ret = device_property_read_u32(i2c_dev->dev, "i2c-scl-rising-time-ns",
1901                                        &rise_time);
1902         if (!ret)
1903                 i2c_dev->setup.rise_time = rise_time;
1904
1905         ret = device_property_read_u32(i2c_dev->dev, "i2c-scl-falling-time-ns",
1906                                        &fall_time);
1907         if (!ret)
1908                 i2c_dev->setup.fall_time = fall_time;
1909
1910         ret = stm32f7_i2c_setup_timing(i2c_dev, &i2c_dev->setup);
1911         if (ret)
1912                 goto clk_free;
1913
1914         stm32f7_i2c_hw_config(i2c_dev);
1915
1916         adap = &i2c_dev->adap;
1917         i2c_set_adapdata(adap, i2c_dev);
1918         snprintf(adap->name, sizeof(adap->name), "STM32F7 I2C(%pa)",
1919                  &res->start);
1920         adap->owner = THIS_MODULE;
1921         adap->timeout = 2 * HZ;
1922         adap->retries = 3;
1923         adap->algo = &stm32f7_i2c_algo;
1924         adap->dev.parent = &pdev->dev;
1925         adap->dev.of_node = pdev->dev.of_node;
1926
1927         init_completion(&i2c_dev->complete);
1928
1929         /* Init DMA config if supported */
1930         i2c_dev->dma = stm32_i2c_dma_request(i2c_dev->dev, phy_addr,
1931                                              STM32F7_I2C_TXDR,
1932                                              STM32F7_I2C_RXDR);
1933         if (PTR_ERR(i2c_dev->dma) == -ENODEV)
1934                 i2c_dev->dma = NULL;
1935         else if (IS_ERR(i2c_dev->dma)) {
1936                 ret = PTR_ERR(i2c_dev->dma);
1937                 if (ret != -EPROBE_DEFER)
1938                         dev_err(&pdev->dev,
1939                                 "Failed to request dma error %i\n", ret);
1940                 goto clk_free;
1941         }
1942
1943         ret = i2c_add_adapter(adap);
1944         if (ret)
1945                 goto clk_free;
1946
1947         platform_set_drvdata(pdev, i2c_dev);
1948
1949         clk_disable(i2c_dev->clk);
1950
1951         dev_info(i2c_dev->dev, "STM32F7 I2C-%d bus adapter\n", adap->nr);
1952
1953         return 0;
1954
1955 clk_free:
1956         clk_disable_unprepare(i2c_dev->clk);
1957
1958         return ret;
1959 }
1960
1961 static int stm32f7_i2c_remove(struct platform_device *pdev)
1962 {
1963         struct stm32f7_i2c_dev *i2c_dev = platform_get_drvdata(pdev);
1964
1965         if (i2c_dev->dma) {
1966                 stm32_i2c_dma_free(i2c_dev->dma);
1967                 i2c_dev->dma = NULL;
1968         }
1969
1970         i2c_del_adapter(&i2c_dev->adap);
1971
1972         clk_unprepare(i2c_dev->clk);
1973
1974         return 0;
1975 }
1976
1977 static const struct of_device_id stm32f7_i2c_match[] = {
1978         { .compatible = "st,stm32f7-i2c", .data = &stm32f7_setup},
1979         {},
1980 };
1981 MODULE_DEVICE_TABLE(of, stm32f7_i2c_match);
1982
1983 static struct platform_driver stm32f7_i2c_driver = {
1984         .driver = {
1985                 .name = "stm32f7-i2c",
1986                 .of_match_table = stm32f7_i2c_match,
1987         },
1988         .probe = stm32f7_i2c_probe,
1989         .remove = stm32f7_i2c_remove,
1990 };
1991
1992 module_platform_driver(stm32f7_i2c_driver);
1993
1994 MODULE_AUTHOR("M'boumba Cedric Madianga <cedric.madianga@gmail.com>");
1995 MODULE_DESCRIPTION("STMicroelectronics STM32F7 I2C driver");
1996 MODULE_LICENSE("GPL v2");