1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) 2 /* 3 * Copyright (c) 2017-2019, STMicroelectronics 4 * 5 * The driver API is defined in header file stm32_i2c.h. 6 * 7 * I2C bus driver does not register to the PM framework. It is the 8 * responsibility of the bus owner to call the related STM32 I2C driver 9 * API functions when bus suspends or resumes. 10 */ 11 12 #include <arm.h> 13 #include <drivers/clk.h> 14 #include <drivers/clk_dt.h> 15 #include <drivers/pinctrl.h> 16 #include <drivers/stm32_gpio.h> 17 #include <drivers/stm32_i2c.h> 18 #include <io.h> 19 #include <kernel/delay.h> 20 #include <kernel/dt.h> 21 #include <kernel/dt_driver.h> 22 #include <kernel/boot.h> 23 #include <kernel/panic.h> 24 #include <libfdt.h> 25 #include <stdbool.h> 26 #include <stdlib.h> 27 #include <stm32_util.h> 28 #include <trace.h> 29 30 /* STM32 I2C registers offsets */ 31 #define I2C_CR1 0x00U 32 #define I2C_CR2 0x04U 33 #define I2C_OAR1 0x08U 34 #define I2C_OAR2 0x0CU 35 #define I2C_TIMINGR 0x10U 36 #define I2C_TIMEOUTR 0x14U 37 #define I2C_ISR 0x18U 38 #define I2C_ICR 0x1CU 39 #define I2C_PECR 0x20U 40 #define I2C_RXDR 0x24U 41 #define I2C_TXDR 0x28U 42 #define I2C_SIZE 0x2CU 43 44 /* Bit definition for I2C_CR1 register */ 45 #define I2C_CR1_PE BIT(0) 46 #define I2C_CR1_TXIE BIT(1) 47 #define I2C_CR1_RXIE BIT(2) 48 #define I2C_CR1_ADDRIE BIT(3) 49 #define I2C_CR1_NACKIE BIT(4) 50 #define I2C_CR1_STOPIE BIT(5) 51 #define I2C_CR1_TCIE BIT(6) 52 #define I2C_CR1_ERRIE BIT(7) 53 #define I2C_CR1_DNF GENMASK_32(11, 8) 54 #define I2C_CR1_ANFOFF BIT(12) 55 #define I2C_CR1_SWRST BIT(13) 56 #define I2C_CR1_TXDMAEN BIT(14) 57 #define I2C_CR1_RXDMAEN BIT(15) 58 #define I2C_CR1_SBC BIT(16) 59 #define I2C_CR1_NOSTRETCH BIT(17) 60 #define I2C_CR1_WUPEN BIT(18) 61 #define I2C_CR1_GCEN BIT(19) 62 #define I2C_CR1_SMBHEN BIT(22) 63 #define I2C_CR1_SMBDEN BIT(21) 64 #define I2C_CR1_ALERTEN BIT(22) 65 #define I2C_CR1_PECEN BIT(23) 66 67 /* Bit definition for I2C_CR2 register */ 68 #define I2C_CR2_SADD GENMASK_32(9, 0) 69 #define I2C_CR2_RD_WRN BIT(10) 70 #define I2C_CR2_RD_WRN_OFFSET 10U 71 #define I2C_CR2_ADD10 BIT(11) 72 #define I2C_CR2_HEAD10R BIT(12) 73 #define I2C_CR2_START BIT(13) 74 #define I2C_CR2_STOP BIT(14) 75 #define I2C_CR2_NACK BIT(15) 76 #define I2C_CR2_NBYTES GENMASK_32(23, 16) 77 #define I2C_CR2_NBYTES_OFFSET 16U 78 #define I2C_CR2_RELOAD BIT(24) 79 #define I2C_CR2_AUTOEND BIT(25) 80 #define I2C_CR2_PECBYTE BIT(26) 81 82 /* Bit definition for I2C_OAR1 register */ 83 #define I2C_OAR1_OA1 GENMASK_32(9, 0) 84 #define I2C_OAR1_OA1MODE BIT(10) 85 #define I2C_OAR1_OA1EN BIT(15) 86 87 /* Bit definition for I2C_OAR2 register */ 88 #define I2C_OAR2_OA2 GENMASK_32(7, 1) 89 #define I2C_OAR2_OA2MSK GENMASK_32(10, 8) 90 #define I2C_OAR2_OA2NOMASK 0 91 #define I2C_OAR2_OA2MASK01 BIT(8) 92 #define I2C_OAR2_OA2MASK02 BIT(9) 93 #define I2C_OAR2_OA2MASK03 GENMASK_32(9, 8) 94 #define I2C_OAR2_OA2MASK04 BIT(10) 95 #define I2C_OAR2_OA2MASK05 (BIT(8) | BIT(10)) 96 #define I2C_OAR2_OA2MASK06 (BIT(9) | BIT(10)) 97 #define I2C_OAR2_OA2MASK07 GENMASK_32(10, 8) 98 #define I2C_OAR2_OA2EN BIT(15) 99 100 /* Bit definition for I2C_TIMINGR register */ 101 #define I2C_TIMINGR_SCLL GENMASK_32(7, 0) 102 #define I2C_TIMINGR_SCLH GENMASK_32(15, 8) 103 #define I2C_TIMINGR_SDADEL GENMASK_32(19, 16) 104 #define I2C_TIMINGR_SCLDEL GENMASK_32(23, 20) 105 #define I2C_TIMINGR_PRESC GENMASK_32(31, 28) 106 #define I2C_TIMINGR_SCLL_MAX (I2C_TIMINGR_SCLL + 1) 107 #define I2C_TIMINGR_SCLH_MAX ((I2C_TIMINGR_SCLH >> 8) + 1) 108 #define I2C_TIMINGR_SDADEL_MAX ((I2C_TIMINGR_SDADEL >> 16) + 1) 109 #define I2C_TIMINGR_SCLDEL_MAX ((I2C_TIMINGR_SCLDEL >> 20) + 1) 110 #define I2C_TIMINGR_PRESC_MAX ((I2C_TIMINGR_PRESC >> 28) + 1) 111 #define I2C_SET_TIMINGR_SCLL(n) ((n) & \ 112 (I2C_TIMINGR_SCLL_MAX - 1)) 113 #define I2C_SET_TIMINGR_SCLH(n) (((n) & \ 114 (I2C_TIMINGR_SCLH_MAX - 1)) << 8) 115 #define I2C_SET_TIMINGR_SDADEL(n) (((n) & \ 116 (I2C_TIMINGR_SDADEL_MAX - 1)) << 16) 117 #define I2C_SET_TIMINGR_SCLDEL(n) (((n) & \ 118 (I2C_TIMINGR_SCLDEL_MAX - 1)) << 20) 119 #define I2C_SET_TIMINGR_PRESC(n) (((n) & \ 120 (I2C_TIMINGR_PRESC_MAX - 1)) << 28) 121 122 /* Bit definition for I2C_TIMEOUTR register */ 123 #define I2C_TIMEOUTR_TIMEOUTA GENMASK_32(11, 0) 124 #define I2C_TIMEOUTR_TIDLE BIT(12) 125 #define I2C_TIMEOUTR_TIMOUTEN BIT(15) 126 #define I2C_TIMEOUTR_TIMEOUTB GENMASK_32(27, 16) 127 #define I2C_TIMEOUTR_TEXTEN BIT(31) 128 129 /* Bit definition for I2C_ISR register */ 130 #define I2C_ISR_TXE BIT(0) 131 #define I2C_ISR_TXIS BIT(1) 132 #define I2C_ISR_RXNE BIT(2) 133 #define I2C_ISR_ADDR BIT(3) 134 #define I2C_ISR_NACKF BIT(4) 135 #define I2C_ISR_STOPF BIT(5) 136 #define I2C_ISR_TC BIT(6) 137 #define I2C_ISR_TCR BIT(7) 138 #define I2C_ISR_BERR BIT(8) 139 #define I2C_ISR_ARLO BIT(9) 140 #define I2C_ISR_OVR BIT(10) 141 #define I2C_ISR_PECERR BIT(11) 142 #define I2C_ISR_TIMEOUT BIT(12) 143 #define I2C_ISR_ALERT BIT(13) 144 #define I2C_ISR_BUSY BIT(15) 145 #define I2C_ISR_DIR BIT(16) 146 #define I2C_ISR_ADDCODE GENMASK_32(23, 17) 147 148 /* Bit definition for I2C_ICR register */ 149 #define I2C_ICR_ADDRCF BIT(3) 150 #define I2C_ICR_NACKCF BIT(4) 151 #define I2C_ICR_STOPCF BIT(5) 152 #define I2C_ICR_BERRCF BIT(8) 153 #define I2C_ICR_ARLOCF BIT(9) 154 #define I2C_ICR_OVRCF BIT(10) 155 #define I2C_ICR_PECCF BIT(11) 156 #define I2C_ICR_TIMOUTCF BIT(12) 157 #define I2C_ICR_ALERTCF BIT(13) 158 159 /* Max data size for a single I2C transfer */ 160 #define MAX_NBYTE_SIZE 255U 161 162 #define I2C_NSEC_PER_SEC 1000000000UL 163 #define I2C_TIMEOUT_BUSY_MS 25 164 #define I2C_TIMEOUT_BUSY_US (I2C_TIMEOUT_BUSY_MS * 1000) 165 #define I2C_TIMEOUT_RXNE_MS 5 166 167 #define I2C_TIMEOUT_DEFAULT_MS 100 168 169 #define CR2_RESET_MASK (I2C_CR2_SADD | I2C_CR2_HEAD10R | \ 170 I2C_CR2_NBYTES | I2C_CR2_RELOAD | \ 171 I2C_CR2_RD_WRN) 172 173 #define TIMINGR_CLEAR_MASK (I2C_TIMINGR_SCLL | I2C_TIMINGR_SCLH | \ 174 I2C_TIMINGR_SDADEL | \ 175 I2C_TIMINGR_SCLDEL | I2C_TIMINGR_PRESC) 176 177 /* 178 * I2C transfer modes 179 * I2C_RELOAD: Enable Reload mode 180 * I2C_AUTOEND_MODE: Enable automatic end mode 181 * I2C_SOFTEND_MODE: Enable software end mode 182 */ 183 #define I2C_RELOAD_MODE I2C_CR2_RELOAD 184 #define I2C_AUTOEND_MODE I2C_CR2_AUTOEND 185 #define I2C_SOFTEND_MODE 0x0 186 187 /* 188 * Start/restart/stop I2C transfer requests. 189 * 190 * I2C_NO_STARTSTOP: Don't Generate stop and start condition 191 * I2C_GENERATE_STOP: Generate stop condition (size should be set to 0) 192 * I2C_GENERATE_START_READ: Generate Restart for read request. 193 * I2C_GENERATE_START_WRITE: Generate Restart for write request 194 */ 195 #define I2C_NO_STARTSTOP 0x0 196 #define I2C_GENERATE_STOP (BIT(31) | I2C_CR2_STOP) 197 #define I2C_GENERATE_START_READ (BIT(31) | I2C_CR2_START | \ 198 I2C_CR2_RD_WRN) 199 #define I2C_GENERATE_START_WRITE (BIT(31) | I2C_CR2_START) 200 201 /* Memory address byte sizes */ 202 #define I2C_MEMADD_SIZE_8BIT 1 203 #define I2C_MEMADD_SIZE_16BIT 2 204 205 /* Effective rate cannot be lower than 80% target rate */ 206 #define RATE_MIN(rate) (((rate) * 80U) / 100U) 207 208 /* 209 * struct i2c_spec_s - Private I2C timing specifications. 210 * @rate: I2C bus speed (Hz) 211 * @fall_max: Max fall time of both SDA and SCL signals (ns) 212 * @rise_max: Max rise time of both SDA and SCL signals (ns) 213 * @hddat_min: Min data hold time (ns) 214 * @vddat_max: Max data valid time (ns) 215 * @sudat_min: Min data setup time (ns) 216 * @l_min: Min low period of the SCL clock (ns) 217 * @h_min: Min high period of the SCL clock (ns) 218 */ 219 struct i2c_spec_s { 220 uint32_t rate; 221 uint32_t fall_max; 222 uint32_t rise_max; 223 uint32_t hddat_min; 224 uint32_t vddat_max; 225 uint32_t sudat_min; 226 uint32_t l_min; 227 uint32_t h_min; 228 }; 229 230 /* 231 * struct i2c_timing_s - Private I2C output parameters. 232 * @scldel: Data setup time 233 * @sdadel: Data hold time 234 * @sclh: SCL high period (master mode) 235 * @sclh: SCL low period (master mode) 236 * @is_saved: True if relating to a configuration candidate 237 */ 238 struct i2c_timing_s { 239 uint8_t scldel; 240 uint8_t sdadel; 241 uint8_t sclh; 242 uint8_t scll; 243 bool is_saved; 244 }; 245 246 /* This table must be sorted in increasing value for field @rate */ 247 static const struct i2c_spec_s i2c_specs[] = { 248 /* Standard - 100KHz */ 249 { 250 .rate = I2C_STANDARD_RATE, 251 .fall_max = 300, 252 .rise_max = 1000, 253 .hddat_min = 0, 254 .vddat_max = 3450, 255 .sudat_min = 250, 256 .l_min = 4700, 257 .h_min = 4000, 258 }, 259 /* Fast - 400KHz */ 260 { 261 .rate = I2C_FAST_RATE, 262 .fall_max = 300, 263 .rise_max = 300, 264 .hddat_min = 0, 265 .vddat_max = 900, 266 .sudat_min = 100, 267 .l_min = 1300, 268 .h_min = 600, 269 }, 270 /* FastPlus - 1MHz */ 271 { 272 .rate = I2C_FAST_PLUS_RATE, 273 .fall_max = 100, 274 .rise_max = 120, 275 .hddat_min = 0, 276 .vddat_max = 450, 277 .sudat_min = 50, 278 .l_min = 500, 279 .h_min = 260, 280 }, 281 }; 282 283 /* 284 * I2C request parameters 285 * @dev_addr: I2C address of the target device 286 * @mode: Communication mode, one of I2C_MODE_(MASTER|MEM) 287 * @mem_addr: Target memory cell accessed in device (memory mode) 288 * @mem_addr_size: Byte size of the memory cell address (memory mode) 289 * @timeout_ms: Timeout in millisenconds for the request 290 */ 291 struct i2c_request { 292 uint32_t dev_addr; 293 enum i2c_mode_e mode; 294 uint32_t mem_addr; 295 uint32_t mem_addr_size; 296 unsigned int timeout_ms; 297 }; 298 299 static vaddr_t get_base(struct i2c_handle_s *hi2c) 300 { 301 return io_pa_or_va_secure(&hi2c->base, hi2c->reg_size); 302 } 303 304 static void notif_i2c_timeout(struct i2c_handle_s *hi2c) 305 { 306 hi2c->i2c_err |= I2C_ERROR_TIMEOUT; 307 hi2c->i2c_state = I2C_STATE_READY; 308 } 309 310 static const struct i2c_spec_s *get_specs(uint32_t rate) 311 { 312 size_t i = 0; 313 314 for (i = 0; i < ARRAY_SIZE(i2c_specs); i++) 315 if (rate <= i2c_specs[i].rate) 316 return i2c_specs + i; 317 318 return NULL; 319 } 320 321 static void save_cfg(struct i2c_handle_s *hi2c, struct i2c_cfg *cfg) 322 { 323 vaddr_t base = get_base(hi2c); 324 325 clk_enable(hi2c->clock); 326 327 cfg->cr1 = io_read32(base + I2C_CR1); 328 cfg->cr2 = io_read32(base + I2C_CR2); 329 cfg->oar1 = io_read32(base + I2C_OAR1); 330 cfg->oar2 = io_read32(base + I2C_OAR2); 331 cfg->timingr = io_read32(base + I2C_TIMINGR); 332 333 clk_disable(hi2c->clock); 334 } 335 336 static void restore_cfg(struct i2c_handle_s *hi2c, struct i2c_cfg *cfg) 337 { 338 vaddr_t base = get_base(hi2c); 339 340 clk_enable(hi2c->clock); 341 342 io_clrbits32(base + I2C_CR1, I2C_CR1_PE); 343 io_write32(base + I2C_TIMINGR, cfg->timingr & TIMINGR_CLEAR_MASK); 344 io_write32(base + I2C_OAR1, cfg->oar1); 345 io_write32(base + I2C_CR2, cfg->cr2); 346 io_write32(base + I2C_OAR2, cfg->oar2); 347 io_write32(base + I2C_CR1, cfg->cr1 & ~I2C_CR1_PE); 348 io_setbits32(base + I2C_CR1, cfg->cr1 & I2C_CR1_PE); 349 350 clk_disable(hi2c->clock); 351 } 352 353 static void __maybe_unused dump_cfg(struct i2c_cfg *cfg __maybe_unused) 354 { 355 DMSG("CR1: %#"PRIx32, cfg->cr1); 356 DMSG("CR2: %#"PRIx32, cfg->cr2); 357 DMSG("OAR1: %#"PRIx32, cfg->oar1); 358 DMSG("OAR2: %#"PRIx32, cfg->oar2); 359 DMSG("TIM: %#"PRIx32, cfg->timingr); 360 } 361 362 static void __maybe_unused dump_i2c(struct i2c_handle_s *hi2c) 363 { 364 vaddr_t __maybe_unused base = get_base(hi2c); 365 366 clk_enable(hi2c->clock); 367 368 DMSG("CR1: %#"PRIx32, io_read32(base + I2C_CR1)); 369 DMSG("CR2: %#"PRIx32, io_read32(base + I2C_CR2)); 370 DMSG("OAR1: %#"PRIx32, io_read32(base + I2C_OAR1)); 371 DMSG("OAR2: %#"PRIx32, io_read32(base + I2C_OAR2)); 372 DMSG("TIM: %#"PRIx32, io_read32(base + I2C_TIMINGR)); 373 374 clk_disable(hi2c->clock); 375 } 376 377 /* 378 * Compute the I2C device timings 379 * 380 * @init: Ref to the initialization configuration structure 381 * @clock_src: I2C clock source frequency (Hz) 382 * @timing: Pointer to the final computed timing result 383 * Return 0 on success or a negative value 384 */ 385 static int i2c_compute_timing(struct stm32_i2c_init_s *init, 386 unsigned long clock_src, uint32_t *timing) 387 { 388 const struct i2c_spec_s *specs = NULL; 389 uint32_t speed_freq = 0; 390 uint32_t i2cbus = UDIV_ROUND_NEAREST(I2C_NSEC_PER_SEC, speed_freq); 391 uint32_t i2cclk = UDIV_ROUND_NEAREST(I2C_NSEC_PER_SEC, clock_src); 392 uint32_t p_prev = I2C_TIMINGR_PRESC_MAX; 393 uint32_t af_delay_min = 0; 394 uint32_t af_delay_max = 0; 395 uint32_t dnf_delay = 0; 396 uint32_t tsync = 0; 397 uint32_t clk_min = 0; 398 uint32_t clk_max = 0; 399 int clk_error_prev = 0; 400 uint16_t p = 0; 401 uint16_t l = 0; 402 uint16_t a = 0; 403 uint16_t h = 0; 404 unsigned int sdadel_min = 0; 405 unsigned int sdadel_max = 0; 406 unsigned int scldel_min = 0; 407 unsigned int delay = 0; 408 int s = -1; 409 struct i2c_timing_s solutions[I2C_TIMINGR_PRESC_MAX] = { 0 }; 410 411 specs = get_specs(init->bus_rate); 412 if (!specs) { 413 DMSG("I2C speed out of bound: %"PRId32"Hz", init->bus_rate); 414 return -1; 415 } 416 417 speed_freq = specs->rate; 418 i2cbus = UDIV_ROUND_NEAREST(I2C_NSEC_PER_SEC, speed_freq); 419 clk_error_prev = INT_MAX; 420 421 if (init->rise_time > specs->rise_max || 422 init->fall_time > specs->fall_max) { 423 DMSG("I2C rise{%"PRId32">%"PRId32"}/fall{%"PRId32">%"PRId32"}", 424 init->rise_time, specs->rise_max, 425 init->fall_time, specs->fall_max); 426 return -1; 427 } 428 429 if (init->digital_filter_coef > STM32_I2C_DIGITAL_FILTER_MAX) { 430 DMSG("DNF out of bound %"PRId8"/%d", 431 init->digital_filter_coef, STM32_I2C_DIGITAL_FILTER_MAX); 432 return -1; 433 } 434 435 /* Analog and Digital Filters */ 436 if (init->analog_filter) { 437 af_delay_min = STM32_I2C_ANALOG_FILTER_DELAY_MIN; 438 af_delay_max = STM32_I2C_ANALOG_FILTER_DELAY_MAX; 439 } 440 dnf_delay = init->digital_filter_coef * i2cclk; 441 442 sdadel_min = specs->hddat_min + init->fall_time; 443 delay = af_delay_min - ((init->digital_filter_coef + 3) * i2cclk); 444 if (SUB_OVERFLOW(sdadel_min, delay, &sdadel_min)) 445 sdadel_min = 0; 446 447 sdadel_max = specs->vddat_max - init->rise_time; 448 delay = af_delay_max - ((init->digital_filter_coef + 4) * i2cclk); 449 if (SUB_OVERFLOW(sdadel_max, delay, &sdadel_max)) 450 sdadel_max = 0; 451 452 scldel_min = init->rise_time + specs->sudat_min; 453 454 DMSG("I2C SDADEL(min/max): %u/%u, SCLDEL(Min): %u", 455 sdadel_min, sdadel_max, scldel_min); 456 457 /* Compute possible values for PRESC, SCLDEL and SDADEL */ 458 for (p = 0; p < I2C_TIMINGR_PRESC_MAX; p++) { 459 for (l = 0; l < I2C_TIMINGR_SCLDEL_MAX; l++) { 460 uint32_t scldel = (l + 1) * (p + 1) * i2cclk; 461 462 if (scldel < scldel_min) 463 continue; 464 465 for (a = 0; a < I2C_TIMINGR_SDADEL_MAX; a++) { 466 uint32_t sdadel = (a * (p + 1) + 1) * i2cclk; 467 468 if ((sdadel >= sdadel_min) && 469 (sdadel <= sdadel_max) && 470 (p != p_prev)) { 471 solutions[p].scldel = l; 472 solutions[p].sdadel = a; 473 solutions[p].is_saved = true; 474 p_prev = p; 475 break; 476 } 477 } 478 479 if (p_prev == p) 480 break; 481 } 482 } 483 484 if (p_prev == I2C_TIMINGR_PRESC_MAX) { 485 DMSG("I2C no Prescaler solution"); 486 return -1; 487 } 488 489 tsync = af_delay_min + dnf_delay + (2 * i2cclk); 490 clk_max = I2C_NSEC_PER_SEC / RATE_MIN(specs->rate); 491 clk_min = I2C_NSEC_PER_SEC / specs->rate; 492 493 /* 494 * Among prescaler possibilities discovered above figures out SCL Low 495 * and High Period. Provided: 496 * - SCL Low Period has to be higher than Low Period of the SCL Clock 497 * defined by I2C Specification. I2C Clock has to be lower than 498 * (SCL Low Period - Analog/Digital filters) / 4. 499 * - SCL High Period has to be lower than High Period of the SCL Clock 500 * defined by I2C Specification. 501 * - I2C Clock has to be lower than SCL High Period. 502 */ 503 for (p = 0; p < I2C_TIMINGR_PRESC_MAX; p++) { 504 uint32_t prescaler = (p + 1) * i2cclk; 505 506 if (!solutions[p].is_saved) 507 continue; 508 509 for (l = 0; l < I2C_TIMINGR_SCLL_MAX; l++) { 510 uint32_t tscl_l = ((l + 1) * prescaler) + tsync; 511 512 if (tscl_l < specs->l_min || 513 i2cclk >= ((tscl_l - af_delay_min - dnf_delay) / 4)) 514 continue; 515 516 for (h = 0; h < I2C_TIMINGR_SCLH_MAX; h++) { 517 uint32_t tscl_h = ((h + 1) * prescaler) + tsync; 518 uint32_t tscl = tscl_l + tscl_h + 519 init->rise_time + 520 init->fall_time; 521 522 if (tscl >= clk_min && tscl <= clk_max && 523 tscl_h >= specs->h_min && i2cclk < tscl_h) { 524 int clk_error = tscl - i2cbus; 525 526 if (clk_error < 0) 527 clk_error = -clk_error; 528 529 if (clk_error < clk_error_prev) { 530 clk_error_prev = clk_error; 531 solutions[p].scll = l; 532 solutions[p].sclh = h; 533 s = p; 534 } 535 } 536 } 537 } 538 } 539 540 if (s < 0) { 541 DMSG("I2C no solution at all"); 542 return -1; 543 } 544 545 /* Finalize timing settings */ 546 *timing = I2C_SET_TIMINGR_PRESC(s) | 547 I2C_SET_TIMINGR_SCLDEL(solutions[s].scldel) | 548 I2C_SET_TIMINGR_SDADEL(solutions[s].sdadel) | 549 I2C_SET_TIMINGR_SCLH(solutions[s].sclh) | 550 I2C_SET_TIMINGR_SCLL(solutions[s].scll); 551 552 DMSG("I2C TIMINGR (PRESC/SCLDEL/SDADEL): %i/%"PRIu8"/%"PRIu8, 553 s, solutions[s].scldel, solutions[s].sdadel); 554 DMSG("I2C TIMINGR (SCLH/SCLL): %"PRIu8"/%"PRIu8, 555 solutions[s].sclh, solutions[s].scll); 556 DMSG("I2C TIMINGR: 0x%"PRIx32, *timing); 557 558 return 0; 559 } 560 561 /* i2c_specs[] must be sorted by increasing rate */ 562 static bool __maybe_unused i2c_specs_is_consistent(void) 563 { 564 size_t i = 0; 565 566 COMPILE_TIME_ASSERT(ARRAY_SIZE(i2c_specs)); 567 568 for (i = 1; i < ARRAY_SIZE(i2c_specs); i++) 569 if (i2c_specs[i - 1].rate >= i2c_specs[i].rate) 570 return false; 571 572 return true; 573 } 574 575 /* 576 * @brief From requested rate, get the closest I2C rate without exceeding it, 577 * within I2C specification values defined in @i2c_specs. 578 * @param rate: The requested rate. 579 * @retval Found rate, else the lowest value supported by platform. 580 */ 581 static uint32_t get_lower_rate(uint32_t rate) 582 { 583 size_t i = 0; 584 585 for (i = ARRAY_SIZE(i2c_specs); i > 0; i--) 586 if (rate > i2c_specs[i - 1].rate) 587 return i2c_specs[i - 1].rate; 588 589 return i2c_specs[0].rate; 590 } 591 592 /* 593 * Setup the I2C device timings 594 * 595 * @hi2c: I2C handle structure 596 * @init: Ref to the initialization configuration structure 597 * @timing: Output TIMINGR register configuration value 598 * @retval 0 if OK, negative value else 599 */ 600 static int i2c_setup_timing(struct i2c_handle_s *hi2c, 601 struct stm32_i2c_init_s *init, 602 uint32_t *timing) 603 { 604 int rc = 0; 605 unsigned long clock_src = 0; 606 607 assert(i2c_specs_is_consistent()); 608 609 clock_src = clk_get_rate(hi2c->clock); 610 if (!clock_src) { 611 DMSG("Null I2C clock rate"); 612 return -1; 613 } 614 615 /* 616 * If the timing has already been computed, and the frequency is the 617 * same as when it was computed, then use the saved timing. 618 */ 619 if (clock_src == hi2c->saved_frequency) { 620 *timing = hi2c->saved_timing; 621 return 0; 622 } 623 624 do { 625 rc = i2c_compute_timing(init, clock_src, timing); 626 if (rc) { 627 DMSG("Failed to compute I2C timings"); 628 if (init->bus_rate > I2C_STANDARD_RATE) { 629 init->bus_rate = get_lower_rate(init->bus_rate); 630 IMSG("Downgrade I2C speed to %"PRIu32"Hz)", 631 init->bus_rate); 632 } else { 633 break; 634 } 635 } 636 } while (rc); 637 638 if (rc) { 639 DMSG("Impossible to compute I2C timings"); 640 return rc; 641 } 642 643 DMSG("I2C Freq(%"PRIu32"Hz), Clk Source(%lu)", 644 init->bus_rate, clock_src); 645 DMSG("I2C Rise(%"PRId32") and Fall(%"PRId32") Time", 646 init->rise_time, init->fall_time); 647 DMSG("I2C Analog Filter(%s), DNF(%"PRIu8")", 648 init->analog_filter ? "On" : "Off", init->digital_filter_coef); 649 650 hi2c->saved_timing = *timing; 651 hi2c->saved_frequency = clock_src; 652 653 return 0; 654 } 655 656 /* 657 * Configure I2C Analog noise filter. 658 * @hi2c: I2C handle structure 659 * @analog_filter_on: True if enabling analog filter, false otherwise 660 * Return 0 on success or a negative value 661 */ 662 static int i2c_config_analog_filter(struct i2c_handle_s *hi2c, 663 bool analog_filter_on) 664 { 665 vaddr_t base = get_base(hi2c); 666 667 if (hi2c->i2c_state != I2C_STATE_READY) 668 return -1; 669 670 hi2c->i2c_state = I2C_STATE_BUSY; 671 672 /* Disable the selected I2C peripheral */ 673 io_clrbits32(base + I2C_CR1, I2C_CR1_PE); 674 675 /* Reset I2Cx ANOFF bit */ 676 io_clrbits32(base + I2C_CR1, I2C_CR1_ANFOFF); 677 678 /* Set analog filter bit if filter is disabled */ 679 if (!analog_filter_on) 680 io_setbits32(base + I2C_CR1, I2C_CR1_ANFOFF); 681 682 /* Enable the selected I2C peripheral */ 683 io_setbits32(base + I2C_CR1, I2C_CR1_PE); 684 685 hi2c->i2c_state = I2C_STATE_READY; 686 687 return 0; 688 } 689 690 TEE_Result stm32_i2c_get_setup_from_fdt(void *fdt, int node, 691 struct stm32_i2c_init_s *init, 692 struct pinctrl_state **pinctrl, 693 struct pinctrl_state **pinctrl_sleep) 694 { 695 TEE_Result res = TEE_ERROR_GENERIC; 696 const fdt32_t *cuint = NULL; 697 struct dt_node_info info = { .status = 0 }; 698 int __maybe_unused count = 0; 699 700 /* Default STM32 specific configs caller may need to overwrite */ 701 memset(init, 0, sizeof(*init)); 702 703 fdt_fill_device_info(fdt, &info, node); 704 assert(info.reg != DT_INFO_INVALID_REG && 705 info.reg_size != DT_INFO_INVALID_REG_SIZE); 706 707 init->dt_status = info.status; 708 init->pbase = info.reg; 709 init->reg_size = info.reg_size; 710 711 res = clk_dt_get_by_index(fdt, node, 0, &init->clock); 712 if (res) 713 return res; 714 715 cuint = fdt_getprop(fdt, node, "i2c-scl-rising-time-ns", NULL); 716 if (cuint) 717 init->rise_time = fdt32_to_cpu(*cuint); 718 else 719 init->rise_time = STM32_I2C_RISE_TIME_DEFAULT; 720 721 cuint = fdt_getprop(fdt, node, "i2c-scl-falling-time-ns", NULL); 722 if (cuint) 723 init->fall_time = fdt32_to_cpu(*cuint); 724 else 725 init->fall_time = STM32_I2C_FALL_TIME_DEFAULT; 726 727 cuint = fdt_getprop(fdt, node, "clock-frequency", NULL); 728 if (cuint) { 729 init->bus_rate = fdt32_to_cpu(*cuint); 730 731 if (init->bus_rate > I2C_FAST_PLUS_RATE) { 732 DMSG("Invalid bus speed (%"PRIu32" > %i)", 733 init->bus_rate, I2C_FAST_PLUS_RATE); 734 return TEE_ERROR_GENERIC; 735 } 736 } else { 737 init->bus_rate = I2C_STANDARD_RATE; 738 } 739 740 if (pinctrl) { 741 res = pinctrl_get_state_by_name(fdt, node, "default", pinctrl); 742 if (res) 743 return res; 744 } 745 746 if (pinctrl_sleep) { 747 res = pinctrl_get_state_by_name(fdt, node, "sleep", 748 pinctrl_sleep); 749 if (res == TEE_ERROR_ITEM_NOT_FOUND) 750 res = TEE_SUCCESS; 751 if (res) 752 return res; 753 } 754 755 return TEE_SUCCESS; 756 } 757 758 int stm32_i2c_init(struct i2c_handle_s *hi2c, 759 struct stm32_i2c_init_s *init_data) 760 { 761 int rc = 0; 762 uint32_t timing = 0; 763 vaddr_t base = 0; 764 uint32_t val = 0; 765 766 rc = i2c_setup_timing(hi2c, init_data, &timing); 767 if (rc) 768 return rc; 769 770 clk_enable(hi2c->clock); 771 772 base = get_base(hi2c); 773 hi2c->i2c_state = I2C_STATE_BUSY; 774 775 /* Disable the selected I2C peripheral */ 776 io_clrbits32(base + I2C_CR1, I2C_CR1_PE); 777 778 /* Configure I2Cx: Frequency range */ 779 io_write32(base + I2C_TIMINGR, timing & TIMINGR_CLEAR_MASK); 780 781 /* Disable Own Address1 before set the Own Address1 configuration */ 782 io_write32(base + I2C_OAR1, 0); 783 784 /* Configure I2Cx: Own Address1 and ack own address1 mode */ 785 if (init_data->addr_mode_10b_not_7b) 786 io_write32(base + I2C_OAR1, 787 I2C_OAR1_OA1EN | I2C_OAR1_OA1MODE | 788 init_data->own_address1); 789 else 790 io_write32(base + I2C_OAR1, 791 I2C_OAR1_OA1EN | init_data->own_address1); 792 793 /* Configure I2Cx: Addressing Master mode */ 794 io_write32(base + I2C_CR2, 0); 795 if (init_data->addr_mode_10b_not_7b) 796 io_setbits32(base + I2C_CR2, I2C_CR2_ADD10); 797 798 /* 799 * Enable the AUTOEND by default, and enable NACK 800 * (should be disabled only during Slave process). 801 */ 802 io_setbits32(base + I2C_CR2, I2C_CR2_AUTOEND | I2C_CR2_NACK); 803 804 /* Disable Own Address2 before set the Own Address2 configuration */ 805 io_write32(base + I2C_OAR2, 0); 806 807 /* Configure I2Cx: Dual mode and Own Address2 */ 808 if (init_data->dual_address_mode) 809 io_write32(base + I2C_OAR2, 810 I2C_OAR2_OA2EN | init_data->own_address2 | 811 (init_data->own_address2_masks << 8)); 812 813 /* Configure I2Cx: Generalcall and NoStretch mode */ 814 val = 0; 815 if (init_data->general_call_mode) 816 val |= I2C_CR1_GCEN; 817 if (init_data->no_stretch_mode) 818 val |= I2C_CR1_NOSTRETCH; 819 io_write32(base + I2C_CR1, val); 820 821 /* Enable the selected I2C peripheral */ 822 io_setbits32(base + I2C_CR1, I2C_CR1_PE); 823 824 hi2c->i2c_err = I2C_ERROR_NONE; 825 hi2c->i2c_state = I2C_STATE_READY; 826 827 rc = i2c_config_analog_filter(hi2c, init_data->analog_filter); 828 if (rc) 829 DMSG("I2C analog filter error %d", rc); 830 831 if (IS_ENABLED(CFG_STM32MP13)) 832 stm32_pinctrl_set_secure_cfg(hi2c->pinctrl, true); 833 834 clk_disable(hi2c->clock); 835 836 return rc; 837 } 838 839 /* I2C transmit (TX) data register flush sequence */ 840 static void i2c_flush_txdr(struct i2c_handle_s *hi2c) 841 { 842 vaddr_t base = get_base(hi2c); 843 844 /* 845 * If a pending TXIS flag is set, 846 * write a dummy data in TXDR to clear it. 847 */ 848 if (io_read32(base + I2C_ISR) & I2C_ISR_TXIS) 849 io_write32(base + I2C_TXDR, 0); 850 851 /* Flush TX register if not empty */ 852 if ((io_read32(base + I2C_ISR) & I2C_ISR_TXE) == 0) 853 io_setbits32(base + I2C_ISR, I2C_ISR_TXE); 854 } 855 856 /* 857 * Wait for a single target I2C_ISR bit to reach an awaited value (0 or 1) 858 * 859 * @hi2c: I2C handle structure 860 * @bit_mask: Bit mask for the target single bit position to consider 861 * @awaited_value: Awaited value of the target bit in I2C_ISR, 0 or 1 862 * @timeout_ref: Expriation timeout reference 863 * Return 0 on success and a non-zero value on timeout 864 */ 865 static int wait_isr_event(struct i2c_handle_s *hi2c, uint32_t bit_mask, 866 unsigned int awaited_value, uint64_t timeout_ref) 867 { 868 vaddr_t isr = get_base(hi2c) + I2C_ISR; 869 870 assert(IS_POWER_OF_TWO(bit_mask) && !(awaited_value & ~1U)); 871 872 /* May timeout while TEE thread is suspended */ 873 while (!timeout_elapsed(timeout_ref)) 874 if (!!(io_read32(isr) & bit_mask) == awaited_value) 875 break; 876 877 if (!!(io_read32(isr) & bit_mask) == awaited_value) 878 return 0; 879 880 notif_i2c_timeout(hi2c); 881 return -1; 882 } 883 884 /* Handle Acknowledge-Failed sequence detection during an I2C Communication */ 885 static int i2c_ack_failed(struct i2c_handle_s *hi2c, uint64_t timeout_ref) 886 { 887 vaddr_t base = get_base(hi2c); 888 889 if ((io_read32(base + I2C_ISR) & I2C_ISR_NACKF) == 0U) 890 return 0; 891 892 /* 893 * Wait until STOP Flag is reset. Use polling method. 894 * AutoEnd should be initiate after AF. 895 * Timeout may elpased while TEE thread is suspended. 896 */ 897 while (!timeout_elapsed(timeout_ref)) 898 if (io_read32(base + I2C_ISR) & I2C_ISR_STOPF) 899 break; 900 901 if ((io_read32(base + I2C_ISR) & I2C_ISR_STOPF) == 0) { 902 notif_i2c_timeout(hi2c); 903 return -1; 904 } 905 906 io_write32(base + I2C_ICR, I2C_ISR_NACKF); 907 908 io_write32(base + I2C_ICR, I2C_ISR_STOPF); 909 910 i2c_flush_txdr(hi2c); 911 912 io_clrbits32(base + I2C_CR2, CR2_RESET_MASK); 913 914 hi2c->i2c_err |= I2C_ERROR_ACKF; 915 hi2c->i2c_state = I2C_STATE_READY; 916 917 return -1; 918 } 919 920 /* Wait TXIS bit is 1 in I2C_ISR register */ 921 static int i2c_wait_txis(struct i2c_handle_s *hi2c, uint64_t timeout_ref) 922 { 923 while (!timeout_elapsed(timeout_ref)) { 924 if (io_read32(get_base(hi2c) + I2C_ISR) & I2C_ISR_TXIS) 925 break; 926 if (i2c_ack_failed(hi2c, timeout_ref)) 927 return -1; 928 } 929 930 if (io_read32(get_base(hi2c) + I2C_ISR) & I2C_ISR_TXIS) 931 return 0; 932 933 if (i2c_ack_failed(hi2c, timeout_ref)) 934 return -1; 935 936 notif_i2c_timeout(hi2c); 937 return -1; 938 } 939 940 /* Wait STOPF bit is 1 in I2C_ISR register */ 941 static int i2c_wait_stop(struct i2c_handle_s *hi2c, uint64_t timeout_ref) 942 { 943 while (!timeout_elapsed(timeout_ref)) { 944 if (io_read32(get_base(hi2c) + I2C_ISR) & I2C_ISR_STOPF) 945 break; 946 947 if (i2c_ack_failed(hi2c, timeout_ref)) 948 return -1; 949 } 950 951 if (io_read32(get_base(hi2c) + I2C_ISR) & I2C_ISR_STOPF) 952 return 0; 953 954 if (i2c_ack_failed(hi2c, timeout_ref)) 955 return -1; 956 957 notif_i2c_timeout(hi2c); 958 return -1; 959 } 960 961 /* 962 * Load I2C_CR2 register for a I2C transfer 963 * 964 * @hi2c: I2C handle structure 965 * @dev_addr: Slave address to be transferred 966 * @size: Number of bytes to be transferred 967 * @i2c_mode: One of I2C_{RELOAD|AUTOEND|SOFTEND}_MODE: Enable Reload mode. 968 * @startstop: One of I2C_NO_STARTSTOP, I2C_GENERATE_STOP, 969 * I2C_GENERATE_START_{READ|WRITE} 970 */ 971 static void i2c_transfer_config(struct i2c_handle_s *hi2c, uint32_t dev_addr, 972 uint32_t size, uint32_t i2c_mode, 973 uint32_t startstop) 974 { 975 uint32_t clr_value = I2C_CR2_SADD | I2C_CR2_NBYTES | I2C_CR2_RELOAD | 976 I2C_CR2_AUTOEND | I2C_CR2_START | I2C_CR2_STOP | 977 (I2C_CR2_RD_WRN & 978 (startstop >> (31U - I2C_CR2_RD_WRN_OFFSET))); 979 uint32_t set_value = (dev_addr & I2C_CR2_SADD) | 980 ((size << I2C_CR2_NBYTES_OFFSET) & 981 I2C_CR2_NBYTES) | 982 i2c_mode | startstop; 983 984 io_clrsetbits32(get_base(hi2c) + I2C_CR2, clr_value, set_value); 985 } 986 987 /* 988 * Master sends target device address followed by internal memory 989 * address for a memory write request. 990 * Function returns 0 on success or a negative value. 991 */ 992 static int i2c_request_mem_write(struct i2c_handle_s *hi2c, 993 struct i2c_request *request, 994 uint64_t timeout_ref) 995 { 996 vaddr_t base = get_base(hi2c); 997 998 i2c_transfer_config(hi2c, request->dev_addr, request->mem_addr_size, 999 I2C_RELOAD_MODE, I2C_GENERATE_START_WRITE); 1000 1001 if (i2c_wait_txis(hi2c, timeout_ref)) 1002 return -1; 1003 1004 if (request->mem_addr_size == I2C_MEMADD_SIZE_8BIT) { 1005 /* Send memory address */ 1006 io_write8(base + I2C_TXDR, request->mem_addr & 0x00FFU); 1007 } else { 1008 /* Send MSB of memory address */ 1009 io_write8(base + I2C_TXDR, (request->mem_addr & 0xFF00U) >> 8); 1010 1011 if (i2c_wait_txis(hi2c, timeout_ref)) 1012 return -1; 1013 1014 /* Send LSB of memory address */ 1015 io_write8(base + I2C_TXDR, request->mem_addr & 0x00FFU); 1016 } 1017 1018 if (wait_isr_event(hi2c, I2C_ISR_TCR, 1, timeout_ref)) 1019 return -1; 1020 1021 return 0; 1022 } 1023 1024 /* 1025 * Master sends target device address followed by internal memory 1026 * address to prepare a memory read request. 1027 * Function returns 0 on success or a negative value. 1028 */ 1029 static int i2c_request_mem_read(struct i2c_handle_s *hi2c, 1030 struct i2c_request *request, 1031 uint64_t timeout_ref) 1032 { 1033 vaddr_t base = get_base(hi2c); 1034 1035 i2c_transfer_config(hi2c, request->dev_addr, request->mem_addr_size, 1036 I2C_SOFTEND_MODE, I2C_GENERATE_START_WRITE); 1037 1038 if (i2c_wait_txis(hi2c, timeout_ref)) 1039 return -1; 1040 1041 if (request->mem_addr_size == I2C_MEMADD_SIZE_8BIT) { 1042 /* Send memory address */ 1043 io_write8(base + I2C_TXDR, request->mem_addr & 0x00FFU); 1044 } else { 1045 /* Send MSB of memory address */ 1046 io_write8(base + I2C_TXDR, (request->mem_addr & 0xFF00U) >> 8); 1047 1048 if (i2c_wait_txis(hi2c, timeout_ref)) 1049 return -1; 1050 1051 /* Send LSB of memory address */ 1052 io_write8(base + I2C_TXDR, request->mem_addr & 0x00FFU); 1053 } 1054 1055 if (wait_isr_event(hi2c, I2C_ISR_TC, 1, timeout_ref)) 1056 return -1; 1057 1058 return 0; 1059 } 1060 1061 /* 1062 * Write an amount of data in blocking mode 1063 * 1064 * @hi2c: Reference to struct i2c_handle_s 1065 * @request: I2C request parameters 1066 * @p_data: Pointer to data buffer 1067 * @size: Amount of data to be sent 1068 * Return 0 on success or a negative value 1069 */ 1070 static int do_write(struct i2c_handle_s *hi2c, struct i2c_request *request, 1071 uint8_t *p_data, uint16_t size) 1072 { 1073 uint64_t timeout_ref = 0; 1074 vaddr_t base = get_base(hi2c); 1075 int rc = -1; 1076 uint8_t *p_buff = p_data; 1077 size_t xfer_size = 0; 1078 size_t xfer_count = size; 1079 1080 if (request->mode != I2C_MODE_MASTER && request->mode != I2C_MODE_MEM) 1081 return -1; 1082 1083 if (hi2c->i2c_state != I2C_STATE_READY) 1084 return -1; 1085 1086 if (!p_data || !size) 1087 return -1; 1088 1089 clk_enable(hi2c->clock); 1090 1091 timeout_ref = timeout_init_us(I2C_TIMEOUT_BUSY_MS * 1000); 1092 if (wait_isr_event(hi2c, I2C_ISR_BUSY, 0, timeout_ref)) 1093 goto bail; 1094 1095 hi2c->i2c_state = I2C_STATE_BUSY_TX; 1096 hi2c->i2c_err = I2C_ERROR_NONE; 1097 timeout_ref = timeout_init_us(request->timeout_ms * 1000); 1098 1099 if (request->mode == I2C_MODE_MEM) { 1100 /* In memory mode, send slave address and memory address */ 1101 if (i2c_request_mem_write(hi2c, request, timeout_ref)) 1102 goto bail; 1103 1104 if (xfer_count > MAX_NBYTE_SIZE) { 1105 xfer_size = MAX_NBYTE_SIZE; 1106 i2c_transfer_config(hi2c, request->dev_addr, xfer_size, 1107 I2C_RELOAD_MODE, I2C_NO_STARTSTOP); 1108 } else { 1109 xfer_size = xfer_count; 1110 i2c_transfer_config(hi2c, request->dev_addr, xfer_size, 1111 I2C_AUTOEND_MODE, I2C_NO_STARTSTOP); 1112 } 1113 } else { 1114 /* In master mode, send slave address */ 1115 if (xfer_count > MAX_NBYTE_SIZE) { 1116 xfer_size = MAX_NBYTE_SIZE; 1117 i2c_transfer_config(hi2c, request->dev_addr, xfer_size, 1118 I2C_RELOAD_MODE, 1119 I2C_GENERATE_START_WRITE); 1120 } else { 1121 xfer_size = xfer_count; 1122 i2c_transfer_config(hi2c, request->dev_addr, xfer_size, 1123 I2C_AUTOEND_MODE, 1124 I2C_GENERATE_START_WRITE); 1125 } 1126 } 1127 1128 do { 1129 if (i2c_wait_txis(hi2c, timeout_ref)) 1130 goto bail; 1131 1132 io_write8(base + I2C_TXDR, *p_buff); 1133 p_buff++; 1134 xfer_count--; 1135 xfer_size--; 1136 1137 if (xfer_count && !xfer_size) { 1138 /* Wait until TCR flag is set */ 1139 if (wait_isr_event(hi2c, I2C_ISR_TCR, 1, timeout_ref)) 1140 goto bail; 1141 1142 if (xfer_count > MAX_NBYTE_SIZE) { 1143 xfer_size = MAX_NBYTE_SIZE; 1144 i2c_transfer_config(hi2c, request->dev_addr, 1145 xfer_size, 1146 I2C_RELOAD_MODE, 1147 I2C_NO_STARTSTOP); 1148 } else { 1149 xfer_size = xfer_count; 1150 i2c_transfer_config(hi2c, request->dev_addr, 1151 xfer_size, 1152 I2C_AUTOEND_MODE, 1153 I2C_NO_STARTSTOP); 1154 } 1155 } 1156 1157 } while (xfer_count > 0U); 1158 1159 /* 1160 * No need to Check TC flag, with AUTOEND mode the stop 1161 * is automatically generated. 1162 * Wait until STOPF flag is reset. 1163 */ 1164 if (i2c_wait_stop(hi2c, timeout_ref)) 1165 goto bail; 1166 1167 io_write32(base + I2C_ICR, I2C_ISR_STOPF); 1168 1169 io_clrbits32(base + I2C_CR2, CR2_RESET_MASK); 1170 1171 hi2c->i2c_state = I2C_STATE_READY; 1172 1173 rc = 0; 1174 1175 bail: 1176 clk_disable(hi2c->clock); 1177 1178 return rc; 1179 } 1180 1181 int stm32_i2c_mem_write(struct i2c_handle_s *hi2c, uint32_t dev_addr, 1182 uint32_t mem_addr, uint32_t mem_addr_size, 1183 uint8_t *p_data, size_t size, unsigned int timeout_ms) 1184 { 1185 struct i2c_request request = { 1186 .dev_addr = dev_addr, 1187 .mode = I2C_MODE_MEM, 1188 .mem_addr = mem_addr, 1189 .mem_addr_size = mem_addr_size, 1190 .timeout_ms = timeout_ms, 1191 }; 1192 1193 return do_write(hi2c, &request, p_data, size); 1194 } 1195 1196 int stm32_i2c_master_transmit(struct i2c_handle_s *hi2c, uint32_t dev_addr, 1197 uint8_t *p_data, size_t size, 1198 unsigned int timeout_ms) 1199 { 1200 struct i2c_request request = { 1201 .dev_addr = dev_addr, 1202 .mode = I2C_MODE_MASTER, 1203 .timeout_ms = timeout_ms, 1204 }; 1205 1206 return do_write(hi2c, &request, p_data, size); 1207 } 1208 1209 int stm32_i2c_read_write_membyte(struct i2c_handle_s *hi2c, uint16_t dev_addr, 1210 unsigned int mem_addr, uint8_t *p_data, 1211 bool write) 1212 { 1213 uint64_t timeout_ref = 0; 1214 uintptr_t base = get_base(hi2c); 1215 int rc = -1; 1216 uint8_t *p_buff = p_data; 1217 uint32_t event_mask = 0; 1218 1219 if (hi2c->i2c_state != I2C_STATE_READY || !p_data) 1220 return -1; 1221 1222 clk_enable(hi2c->clock); 1223 1224 timeout_ref = timeout_init_us(I2C_TIMEOUT_BUSY_US); 1225 if (wait_isr_event(hi2c, I2C_ISR_BUSY, 0, timeout_ref)) 1226 goto bail; 1227 1228 hi2c->i2c_state = write ? I2C_STATE_BUSY_TX : I2C_STATE_BUSY_RX; 1229 hi2c->i2c_err = I2C_ERROR_NONE; 1230 1231 i2c_transfer_config(hi2c, dev_addr, I2C_MEMADD_SIZE_8BIT, 1232 write ? I2C_RELOAD_MODE : I2C_SOFTEND_MODE, 1233 I2C_GENERATE_START_WRITE); 1234 1235 timeout_ref = timeout_init_us(I2C_TIMEOUT_BUSY_US); 1236 if (i2c_wait_txis(hi2c, timeout_ref)) 1237 goto bail; 1238 1239 io_write8(base + I2C_TXDR, mem_addr); 1240 1241 if (write) 1242 event_mask = I2C_ISR_TCR; 1243 else 1244 event_mask = I2C_ISR_TC; 1245 1246 timeout_ref = timeout_init_us(I2C_TIMEOUT_BUSY_US); 1247 if (wait_isr_event(hi2c, event_mask, 1, timeout_ref)) 1248 goto bail; 1249 1250 i2c_transfer_config(hi2c, dev_addr, I2C_MEMADD_SIZE_8BIT, 1251 I2C_AUTOEND_MODE, 1252 write ? I2C_NO_STARTSTOP : I2C_GENERATE_START_READ); 1253 1254 timeout_ref = timeout_init_us(I2C_TIMEOUT_BUSY_US); 1255 if (write) { 1256 if (i2c_wait_txis(hi2c, timeout_ref)) 1257 goto bail; 1258 1259 io_write8(base + I2C_TXDR, *p_buff); 1260 } else { 1261 if (wait_isr_event(hi2c, I2C_ISR_RXNE, 1, timeout_ref)) 1262 goto bail; 1263 1264 *p_buff = io_read8(base + I2C_RXDR); 1265 } 1266 1267 timeout_ref = timeout_init_us(I2C_TIMEOUT_BUSY_US); 1268 if (i2c_wait_stop(hi2c, timeout_ref)) 1269 goto bail; 1270 1271 io_write32(base + I2C_ICR, I2C_ISR_STOPF); 1272 io_clrbits32(base + I2C_CR2, CR2_RESET_MASK); 1273 1274 hi2c->i2c_state = I2C_STATE_READY; 1275 1276 rc = 0; 1277 1278 bail: 1279 clk_disable(hi2c->clock); 1280 1281 return rc; 1282 } 1283 1284 /* 1285 * Read an amount of data in blocking mode 1286 * 1287 * @hi2c: Reference to struct i2c_handle_s 1288 * @request: I2C request parameters 1289 * @p_data: Pointer to data buffer 1290 * @size: Amount of data to be sent 1291 * Return 0 on success or a negative value 1292 */ 1293 static int do_read(struct i2c_handle_s *hi2c, struct i2c_request *request, 1294 uint8_t *p_data, uint32_t size) 1295 { 1296 vaddr_t base = get_base(hi2c); 1297 uint64_t timeout_ref = 0; 1298 int rc = -1; 1299 uint8_t *p_buff = p_data; 1300 size_t xfer_count = size; 1301 size_t xfer_size = 0; 1302 1303 if (request->mode != I2C_MODE_MASTER && request->mode != I2C_MODE_MEM) 1304 return -1; 1305 1306 if (hi2c->i2c_state != I2C_STATE_READY) 1307 return -1; 1308 1309 if (!p_data || !size) 1310 return -1; 1311 1312 clk_enable(hi2c->clock); 1313 1314 timeout_ref = timeout_init_us(I2C_TIMEOUT_BUSY_MS * 1000); 1315 if (wait_isr_event(hi2c, I2C_ISR_BUSY, 0, timeout_ref)) 1316 goto bail; 1317 1318 hi2c->i2c_state = I2C_STATE_BUSY_RX; 1319 hi2c->i2c_err = I2C_ERROR_NONE; 1320 timeout_ref = timeout_init_us(request->timeout_ms * 1000); 1321 1322 if (request->mode == I2C_MODE_MEM) { 1323 /* Send memory address */ 1324 if (i2c_request_mem_read(hi2c, request, timeout_ref)) 1325 goto bail; 1326 } 1327 1328 /* 1329 * Send slave address. 1330 * Set NBYTES to write and reload if xfer_count > MAX_NBYTE_SIZE 1331 * and generate RESTART. 1332 */ 1333 if (xfer_count > MAX_NBYTE_SIZE) { 1334 xfer_size = MAX_NBYTE_SIZE; 1335 i2c_transfer_config(hi2c, request->dev_addr, xfer_size, 1336 I2C_RELOAD_MODE, I2C_GENERATE_START_READ); 1337 } else { 1338 xfer_size = xfer_count; 1339 i2c_transfer_config(hi2c, request->dev_addr, xfer_size, 1340 I2C_AUTOEND_MODE, I2C_GENERATE_START_READ); 1341 } 1342 1343 do { 1344 if (wait_isr_event(hi2c, I2C_ISR_RXNE, 1, 1345 timeout_init_us(I2C_TIMEOUT_RXNE_MS * 1000))) 1346 goto bail; 1347 1348 *p_buff = io_read8(base + I2C_RXDR); 1349 p_buff++; 1350 xfer_size--; 1351 xfer_count--; 1352 1353 if (xfer_count && !xfer_size) { 1354 if (wait_isr_event(hi2c, I2C_ISR_TCR, 1, timeout_ref)) 1355 goto bail; 1356 1357 if (xfer_count > MAX_NBYTE_SIZE) { 1358 xfer_size = MAX_NBYTE_SIZE; 1359 i2c_transfer_config(hi2c, request->dev_addr, 1360 xfer_size, 1361 I2C_RELOAD_MODE, 1362 I2C_NO_STARTSTOP); 1363 } else { 1364 xfer_size = xfer_count; 1365 i2c_transfer_config(hi2c, request->dev_addr, 1366 xfer_size, 1367 I2C_AUTOEND_MODE, 1368 I2C_NO_STARTSTOP); 1369 } 1370 } 1371 } while (xfer_count > 0U); 1372 1373 /* 1374 * No need to Check TC flag, with AUTOEND mode the stop 1375 * is automatically generated. 1376 * Wait until STOPF flag is reset. 1377 */ 1378 if (i2c_wait_stop(hi2c, timeout_ref)) 1379 goto bail; 1380 1381 /* Clear the NACK generated at the end of the transfer */ 1382 if ((io_read32(get_base(hi2c) + I2C_ISR) & I2C_ISR_NACKF)) 1383 io_write32(get_base(hi2c) + I2C_ICR, I2C_ICR_NACKCF); 1384 1385 io_write32(base + I2C_ICR, I2C_ISR_STOPF); 1386 1387 io_clrbits32(base + I2C_CR2, CR2_RESET_MASK); 1388 1389 hi2c->i2c_state = I2C_STATE_READY; 1390 1391 rc = 0; 1392 1393 bail: 1394 clk_disable(hi2c->clock); 1395 1396 return rc; 1397 } 1398 1399 int stm32_i2c_mem_read(struct i2c_handle_s *hi2c, uint32_t dev_addr, 1400 uint32_t mem_addr, uint32_t mem_addr_size, 1401 uint8_t *p_data, size_t size, unsigned int timeout_ms) 1402 { 1403 struct i2c_request request = { 1404 .dev_addr = dev_addr, 1405 .mode = I2C_MODE_MEM, 1406 .mem_addr = mem_addr, 1407 .mem_addr_size = mem_addr_size, 1408 .timeout_ms = timeout_ms, 1409 }; 1410 1411 return do_read(hi2c, &request, p_data, size); 1412 } 1413 1414 int stm32_i2c_master_receive(struct i2c_handle_s *hi2c, uint32_t dev_addr, 1415 uint8_t *p_data, size_t size, 1416 unsigned int timeout_ms) 1417 { 1418 struct i2c_request request = { 1419 .dev_addr = dev_addr, 1420 .mode = I2C_MODE_MASTER, 1421 .timeout_ms = timeout_ms, 1422 }; 1423 1424 return do_read(hi2c, &request, p_data, size); 1425 } 1426 1427 static struct i2c_handle_s *stm32_i2c_dev_to_handle(struct i2c_dev *i2c_dev) 1428 { 1429 struct stm32_i2c_dev *dev = container_of(i2c_dev, struct stm32_i2c_dev, 1430 i2c_dev); 1431 1432 return dev->handle; 1433 } 1434 1435 static TEE_Result stm32_i2c_read_data(struct i2c_dev *i2c_dev, uint8_t *buf, 1436 size_t len) 1437 { 1438 struct i2c_handle_s *i2c_handle = stm32_i2c_dev_to_handle(i2c_dev); 1439 int rc = 0; 1440 1441 rc = stm32_i2c_master_receive(i2c_handle, i2c_dev->addr, buf, len, 1442 I2C_TIMEOUT_DEFAULT_MS); 1443 if (!rc) 1444 return TEE_SUCCESS; 1445 else 1446 return TEE_ERROR_GENERIC; 1447 } 1448 1449 static TEE_Result stm32_i2c_write_data(struct i2c_dev *i2c_dev, 1450 const uint8_t *buf, size_t len) 1451 { 1452 struct i2c_handle_s *i2c_handle = stm32_i2c_dev_to_handle(i2c_dev); 1453 uint8_t *buf2 = (uint8_t *)buf; 1454 int rc = 0; 1455 1456 rc = stm32_i2c_master_transmit(i2c_handle, i2c_dev->addr, buf2, len, 1457 I2C_TIMEOUT_DEFAULT_MS); 1458 if (!rc) 1459 return TEE_SUCCESS; 1460 else 1461 return TEE_ERROR_GENERIC; 1462 } 1463 1464 static const struct i2c_ctrl_ops stm32_i2c_ops = { 1465 .read = stm32_i2c_read_data, 1466 .write = stm32_i2c_write_data, 1467 }; 1468 1469 bool stm32_i2c_is_device_ready(struct i2c_handle_s *hi2c, uint32_t dev_addr, 1470 unsigned int trials, unsigned int timeout_ms) 1471 { 1472 vaddr_t base = get_base(hi2c); 1473 unsigned int i2c_trials = 0U; 1474 bool rc = false; 1475 1476 if (hi2c->i2c_state != I2C_STATE_READY) 1477 return rc; 1478 1479 clk_enable(hi2c->clock); 1480 1481 if (io_read32(base + I2C_ISR) & I2C_ISR_BUSY) 1482 goto bail; 1483 1484 hi2c->i2c_state = I2C_STATE_BUSY; 1485 hi2c->i2c_err = I2C_ERROR_NONE; 1486 1487 do { 1488 uint64_t timeout_ref = 0; 1489 vaddr_t isr = base + I2C_ISR; 1490 1491 /* Generate Start */ 1492 if ((io_read32(base + I2C_OAR1) & I2C_OAR1_OA1MODE) == 0) 1493 io_write32(base + I2C_CR2, 1494 ((dev_addr & I2C_CR2_SADD) | 1495 I2C_CR2_START | I2C_CR2_AUTOEND) & 1496 ~I2C_CR2_RD_WRN); 1497 else 1498 io_write32(base + I2C_CR2, 1499 ((dev_addr & I2C_CR2_SADD) | 1500 I2C_CR2_START | I2C_CR2_ADD10) & 1501 ~I2C_CR2_RD_WRN); 1502 1503 /* 1504 * No need to Check TC flag, with AUTOEND mode the stop 1505 * is automatically generated. 1506 * Wait until STOPF flag is set or a NACK flag is set. 1507 */ 1508 timeout_ref = timeout_init_us(timeout_ms * 1000); 1509 while (!timeout_elapsed(timeout_ref)) 1510 if (io_read32(isr) & (I2C_ISR_STOPF | I2C_ISR_NACKF)) 1511 break; 1512 1513 if ((io_read32(isr) & (I2C_ISR_STOPF | I2C_ISR_NACKF)) == 0) { 1514 notif_i2c_timeout(hi2c); 1515 goto bail; 1516 } 1517 1518 if ((io_read32(base + I2C_ISR) & I2C_ISR_NACKF) == 0U) { 1519 if (wait_isr_event(hi2c, I2C_ISR_STOPF, 1, timeout_ref)) 1520 goto bail; 1521 1522 io_write32(base + I2C_ICR, I2C_ISR_STOPF); 1523 1524 hi2c->i2c_state = I2C_STATE_READY; 1525 1526 rc = true; 1527 goto bail; 1528 } 1529 1530 if (wait_isr_event(hi2c, I2C_ISR_STOPF, 1, timeout_ref)) 1531 goto bail; 1532 1533 io_write32(base + I2C_ICR, I2C_ISR_NACKF); 1534 io_write32(base + I2C_ICR, I2C_ISR_STOPF); 1535 1536 if (i2c_trials == trials) { 1537 io_setbits32(base + I2C_CR2, I2C_CR2_STOP); 1538 1539 if (wait_isr_event(hi2c, I2C_ISR_STOPF, 1, timeout_ref)) 1540 goto bail; 1541 1542 io_write32(base + I2C_ICR, I2C_ISR_STOPF); 1543 } 1544 1545 i2c_trials++; 1546 } while (i2c_trials < trials); 1547 1548 notif_i2c_timeout(hi2c); 1549 1550 bail: 1551 clk_disable(hi2c->clock); 1552 1553 return rc; 1554 } 1555 1556 void stm32_i2c_resume(struct i2c_handle_s *hi2c) 1557 { 1558 if (hi2c->i2c_state == I2C_STATE_READY) 1559 return; 1560 1561 if ((hi2c->i2c_state != I2C_STATE_RESET) && 1562 (hi2c->i2c_state != I2C_STATE_SUSPENDED)) 1563 panic(); 1564 1565 if (pinctrl_apply_state(hi2c->pinctrl)) 1566 panic(); 1567 1568 if (hi2c->i2c_state == I2C_STATE_RESET) { 1569 /* There is no valid I2C configuration to be loaded yet */ 1570 return; 1571 } 1572 1573 restore_cfg(hi2c, &hi2c->sec_cfg); 1574 1575 if (IS_ENABLED(CFG_STM32MP13)) 1576 stm32_pinctrl_set_secure_cfg(hi2c->pinctrl, true); 1577 1578 hi2c->i2c_state = I2C_STATE_READY; 1579 } 1580 1581 void stm32_i2c_suspend(struct i2c_handle_s *hi2c) 1582 { 1583 if (hi2c->i2c_state == I2C_STATE_SUSPENDED) 1584 return; 1585 1586 if (hi2c->i2c_state != I2C_STATE_READY) 1587 panic(); 1588 1589 save_cfg(hi2c, &hi2c->sec_cfg); 1590 1591 if (hi2c->pinctrl_sleep && pinctrl_apply_state(hi2c->pinctrl_sleep)) 1592 panic(); 1593 1594 hi2c->i2c_state = I2C_STATE_SUSPENDED; 1595 } 1596 1597 static TEE_Result stm32_get_i2c_dev(struct dt_pargs *args, void *data, 1598 struct i2c_dev **out_device) 1599 { 1600 struct stm32_i2c_dev *stm32_i2c_dev = NULL; 1601 paddr_t addr = 0; 1602 1603 addr = fdt_reg_base_address(args->fdt, args->phandle_node); 1604 if (addr == DT_INFO_INVALID_REG) { 1605 DMSG("Can't get device I2C address"); 1606 return TEE_ERROR_GENERIC; 1607 } 1608 1609 stm32_i2c_dev = calloc(1, sizeof(*stm32_i2c_dev)); 1610 if (!stm32_i2c_dev) 1611 return TEE_ERROR_OUT_OF_MEMORY; 1612 1613 stm32_i2c_dev->handle = data; 1614 stm32_i2c_dev->i2c_dev.addr = addr; 1615 stm32_i2c_dev->i2c_ctrl.ops = &stm32_i2c_ops; 1616 stm32_i2c_dev->i2c_dev.ctrl = &stm32_i2c_dev->i2c_ctrl; 1617 1618 *out_device = &stm32_i2c_dev->i2c_dev; 1619 1620 return TEE_SUCCESS; 1621 } 1622 1623 static TEE_Result stm32_i2c_probe(const void *fdt, int node, 1624 const void *compat_data __unused) 1625 { 1626 TEE_Result res = TEE_SUCCESS; 1627 int subnode = 0; 1628 struct i2c_handle_s *i2c_handle_p = NULL; 1629 struct stm32_i2c_init_s init_data = { }; 1630 struct pinctrl_state *pinctrl_active = NULL; 1631 struct pinctrl_state *pinctrl_idle = NULL; 1632 1633 res = stm32_i2c_get_setup_from_fdt((void *)fdt, node, &init_data, 1634 &pinctrl_active, &pinctrl_idle); 1635 if (res) 1636 return res; 1637 1638 i2c_handle_p = calloc(1, sizeof(struct i2c_handle_s)); 1639 if (!i2c_handle_p) 1640 return TEE_ERROR_OUT_OF_MEMORY; 1641 1642 i2c_handle_p->dt_status = init_data.dt_status; 1643 i2c_handle_p->reg_size = init_data.reg_size; 1644 i2c_handle_p->clock = init_data.clock; 1645 i2c_handle_p->base.pa = init_data.pbase; 1646 i2c_handle_p->base.va = io_pa_or_va(&i2c_handle_p->base, 1647 init_data.reg_size); 1648 assert(i2c_handle_p->base.va); 1649 i2c_handle_p->clock = init_data.clock; 1650 i2c_handle_p->i2c_state = I2C_STATE_RESET; 1651 i2c_handle_p->pinctrl = pinctrl_active; 1652 i2c_handle_p->pinctrl_sleep = pinctrl_idle; 1653 1654 init_data.analog_filter = true; 1655 init_data.digital_filter_coef = 0; 1656 1657 res = stm32_i2c_init(i2c_handle_p, &init_data); 1658 if (res) 1659 panic("Couldn't initialise I2C"); 1660 1661 res = i2c_register_provider(fdt, node, stm32_get_i2c_dev, i2c_handle_p); 1662 if (res) 1663 panic("Couldn't register I2C provider"); 1664 1665 fdt_for_each_subnode(subnode, fdt, node) { 1666 res = dt_driver_maybe_add_probe_node(fdt, subnode); 1667 if (res) { 1668 EMSG("Failed on node %s with %#"PRIx32, 1669 fdt_get_name(fdt, subnode, NULL), res); 1670 panic(); 1671 } 1672 } 1673 1674 return res; 1675 } 1676 1677 static const struct dt_device_match stm32_i2c_match_table[] = { 1678 { .compatible = "st,stm32mp15-i2c" }, 1679 { .compatible = "st,stm32mp13-i2c" }, 1680 { .compatible = "st,stm32mp15-i2c-non-secure" }, 1681 { } 1682 }; 1683 1684 DEFINE_DT_DRIVER(stm32_i2c_dt_driver) = { 1685 .name = "stm32_i2c", 1686 .match_table = stm32_i2c_match_table, 1687 .probe = stm32_i2c_probe, 1688 .type = DT_DRIVER_I2C 1689 }; 1690