1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 285b4fab2SMaxime COQUELIN /* 385b4fab2SMaxime COQUELIN * Copyright (C) 2013 STMicroelectronics 485b4fab2SMaxime COQUELIN * 585b4fab2SMaxime COQUELIN * I2C master mode controller driver, used in STMicroelectronics devices. 685b4fab2SMaxime COQUELIN * 785b4fab2SMaxime COQUELIN * Author: Maxime Coquelin <maxime.coquelin@st.com> 885b4fab2SMaxime COQUELIN */ 985b4fab2SMaxime COQUELIN 1085b4fab2SMaxime COQUELIN #include <linux/clk.h> 1185b4fab2SMaxime COQUELIN #include <linux/delay.h> 1285b4fab2SMaxime COQUELIN #include <linux/err.h> 13fcdd5f09SWolfram Sang #include <linux/i2c.h> 14fcdd5f09SWolfram Sang #include <linux/interrupt.h> 15fcdd5f09SWolfram Sang #include <linux/io.h> 16fcdd5f09SWolfram Sang #include <linux/module.h> 1785b4fab2SMaxime COQUELIN #include <linux/of_address.h> 1885b4fab2SMaxime COQUELIN #include <linux/of_irq.h> 19fcdd5f09SWolfram Sang #include <linux/of.h> 20fcdd5f09SWolfram Sang #include <linux/pinctrl/consumer.h> 21fcdd5f09SWolfram Sang #include <linux/platform_device.h> 2285b4fab2SMaxime COQUELIN 2385b4fab2SMaxime COQUELIN /* SSC registers */ 2485b4fab2SMaxime COQUELIN #define SSC_BRG 0x000 2585b4fab2SMaxime COQUELIN #define SSC_TBUF 0x004 2685b4fab2SMaxime COQUELIN #define SSC_RBUF 0x008 2785b4fab2SMaxime COQUELIN #define SSC_CTL 0x00C 2885b4fab2SMaxime COQUELIN #define SSC_IEN 0x010 2985b4fab2SMaxime COQUELIN #define SSC_STA 0x014 3085b4fab2SMaxime COQUELIN #define SSC_I2C 0x018 3185b4fab2SMaxime COQUELIN #define SSC_SLAD 0x01C 3285b4fab2SMaxime COQUELIN #define SSC_REP_START_HOLD 0x020 3385b4fab2SMaxime COQUELIN #define SSC_START_HOLD 0x024 3485b4fab2SMaxime COQUELIN #define SSC_REP_START_SETUP 0x028 3585b4fab2SMaxime COQUELIN #define SSC_DATA_SETUP 0x02C 3685b4fab2SMaxime COQUELIN #define SSC_STOP_SETUP 0x030 3785b4fab2SMaxime COQUELIN #define SSC_BUS_FREE 0x034 3885b4fab2SMaxime COQUELIN #define SSC_TX_FSTAT 0x038 3985b4fab2SMaxime COQUELIN #define SSC_RX_FSTAT 0x03C 4085b4fab2SMaxime COQUELIN #define SSC_PRE_SCALER_BRG 0x040 4185b4fab2SMaxime COQUELIN #define SSC_CLR 0x080 4285b4fab2SMaxime COQUELIN #define SSC_NOISE_SUPP_WIDTH 0x100 4385b4fab2SMaxime COQUELIN #define SSC_PRSCALER 0x104 4485b4fab2SMaxime COQUELIN #define SSC_NOISE_SUPP_WIDTH_DATAOUT 0x108 4585b4fab2SMaxime COQUELIN #define SSC_PRSCALER_DATAOUT 0x10c 4685b4fab2SMaxime COQUELIN 4785b4fab2SMaxime COQUELIN /* SSC Control */ 4885b4fab2SMaxime COQUELIN #define SSC_CTL_DATA_WIDTH_9 0x8 4985b4fab2SMaxime COQUELIN #define SSC_CTL_DATA_WIDTH_MSK 0xf 5085b4fab2SMaxime COQUELIN #define SSC_CTL_BM 0xf 5185b4fab2SMaxime COQUELIN #define SSC_CTL_HB BIT(4) 5285b4fab2SMaxime COQUELIN #define SSC_CTL_PH BIT(5) 5385b4fab2SMaxime COQUELIN #define SSC_CTL_PO BIT(6) 5485b4fab2SMaxime COQUELIN #define SSC_CTL_SR BIT(7) 5585b4fab2SMaxime COQUELIN #define SSC_CTL_MS BIT(8) 5685b4fab2SMaxime COQUELIN #define SSC_CTL_EN BIT(9) 5785b4fab2SMaxime COQUELIN #define SSC_CTL_LPB BIT(10) 5885b4fab2SMaxime COQUELIN #define SSC_CTL_EN_TX_FIFO BIT(11) 5985b4fab2SMaxime COQUELIN #define SSC_CTL_EN_RX_FIFO BIT(12) 6085b4fab2SMaxime COQUELIN #define SSC_CTL_EN_CLST_RX BIT(13) 6185b4fab2SMaxime COQUELIN 6285b4fab2SMaxime COQUELIN /* SSC Interrupt Enable */ 6385b4fab2SMaxime COQUELIN #define SSC_IEN_RIEN BIT(0) 6485b4fab2SMaxime COQUELIN #define SSC_IEN_TIEN BIT(1) 6585b4fab2SMaxime COQUELIN #define SSC_IEN_TEEN BIT(2) 6685b4fab2SMaxime COQUELIN #define SSC_IEN_REEN BIT(3) 6785b4fab2SMaxime COQUELIN #define SSC_IEN_PEEN BIT(4) 6885b4fab2SMaxime COQUELIN #define SSC_IEN_AASEN BIT(6) 6985b4fab2SMaxime COQUELIN #define SSC_IEN_STOPEN BIT(7) 7085b4fab2SMaxime COQUELIN #define SSC_IEN_ARBLEN BIT(8) 7185b4fab2SMaxime COQUELIN #define SSC_IEN_NACKEN BIT(10) 7285b4fab2SMaxime COQUELIN #define SSC_IEN_REPSTRTEN BIT(11) 7385b4fab2SMaxime COQUELIN #define SSC_IEN_TX_FIFO_HALF BIT(12) 7485b4fab2SMaxime COQUELIN #define SSC_IEN_RX_FIFO_HALF_FULL BIT(14) 7585b4fab2SMaxime COQUELIN 7685b4fab2SMaxime COQUELIN /* SSC Status */ 7785b4fab2SMaxime COQUELIN #define SSC_STA_RIR BIT(0) 7885b4fab2SMaxime COQUELIN #define SSC_STA_TIR BIT(1) 7985b4fab2SMaxime COQUELIN #define SSC_STA_TE BIT(2) 8085b4fab2SMaxime COQUELIN #define SSC_STA_RE BIT(3) 8185b4fab2SMaxime COQUELIN #define SSC_STA_PE BIT(4) 8285b4fab2SMaxime COQUELIN #define SSC_STA_CLST BIT(5) 8385b4fab2SMaxime COQUELIN #define SSC_STA_AAS BIT(6) 8485b4fab2SMaxime COQUELIN #define SSC_STA_STOP BIT(7) 8585b4fab2SMaxime COQUELIN #define SSC_STA_ARBL BIT(8) 8685b4fab2SMaxime COQUELIN #define SSC_STA_BUSY BIT(9) 8785b4fab2SMaxime COQUELIN #define SSC_STA_NACK BIT(10) 8885b4fab2SMaxime COQUELIN #define SSC_STA_REPSTRT BIT(11) 8985b4fab2SMaxime COQUELIN #define SSC_STA_TX_FIFO_HALF BIT(12) 9085b4fab2SMaxime COQUELIN #define SSC_STA_TX_FIFO_FULL BIT(13) 9185b4fab2SMaxime COQUELIN #define SSC_STA_RX_FIFO_HALF BIT(14) 9285b4fab2SMaxime COQUELIN 9385b4fab2SMaxime COQUELIN /* SSC I2C Control */ 9485b4fab2SMaxime COQUELIN #define SSC_I2C_I2CM BIT(0) 9585b4fab2SMaxime COQUELIN #define SSC_I2C_STRTG BIT(1) 9685b4fab2SMaxime COQUELIN #define SSC_I2C_STOPG BIT(2) 9785b4fab2SMaxime COQUELIN #define SSC_I2C_ACKG BIT(3) 9885b4fab2SMaxime COQUELIN #define SSC_I2C_AD10 BIT(4) 9985b4fab2SMaxime COQUELIN #define SSC_I2C_TXENB BIT(5) 10085b4fab2SMaxime COQUELIN #define SSC_I2C_REPSTRTG BIT(11) 10185b4fab2SMaxime COQUELIN #define SSC_I2C_SLAVE_DISABLE BIT(12) 10285b4fab2SMaxime COQUELIN 10385b4fab2SMaxime COQUELIN /* SSC Tx FIFO Status */ 10485b4fab2SMaxime COQUELIN #define SSC_TX_FSTAT_STATUS 0x07 10585b4fab2SMaxime COQUELIN 10685b4fab2SMaxime COQUELIN /* SSC Rx FIFO Status */ 10785b4fab2SMaxime COQUELIN #define SSC_RX_FSTAT_STATUS 0x07 10885b4fab2SMaxime COQUELIN 10985b4fab2SMaxime COQUELIN /* SSC Clear bit operation */ 11085b4fab2SMaxime COQUELIN #define SSC_CLR_SSCAAS BIT(6) 11185b4fab2SMaxime COQUELIN #define SSC_CLR_SSCSTOP BIT(7) 11285b4fab2SMaxime COQUELIN #define SSC_CLR_SSCARBL BIT(8) 11385b4fab2SMaxime COQUELIN #define SSC_CLR_NACK BIT(10) 11485b4fab2SMaxime COQUELIN #define SSC_CLR_REPSTRT BIT(11) 11585b4fab2SMaxime COQUELIN 11685b4fab2SMaxime COQUELIN /* SSC Clock Prescaler */ 11785b4fab2SMaxime COQUELIN #define SSC_PRSC_VALUE 0x0f 11885b4fab2SMaxime COQUELIN 11985b4fab2SMaxime COQUELIN 12085b4fab2SMaxime COQUELIN #define SSC_TXFIFO_SIZE 0x8 12185b4fab2SMaxime COQUELIN #define SSC_RXFIFO_SIZE 0x8 12285b4fab2SMaxime COQUELIN 12385b4fab2SMaxime COQUELIN enum st_i2c_mode { 12485b4fab2SMaxime COQUELIN I2C_MODE_STANDARD, 12585b4fab2SMaxime COQUELIN I2C_MODE_FAST, 12685b4fab2SMaxime COQUELIN I2C_MODE_END, 12785b4fab2SMaxime COQUELIN }; 12885b4fab2SMaxime COQUELIN 12985b4fab2SMaxime COQUELIN /** 13085b4fab2SMaxime COQUELIN * struct st_i2c_timings - per-Mode tuning parameters 13185b4fab2SMaxime COQUELIN * @rate: I2C bus rate 13285b4fab2SMaxime COQUELIN * @rep_start_hold: I2C repeated start hold time requirement 13385b4fab2SMaxime COQUELIN * @rep_start_setup: I2C repeated start set up time requirement 13485b4fab2SMaxime COQUELIN * @start_hold: I2C start hold time requirement 13585b4fab2SMaxime COQUELIN * @data_setup_time: I2C data set up time requirement 13685b4fab2SMaxime COQUELIN * @stop_setup_time: I2C stop set up time requirement 13785b4fab2SMaxime COQUELIN * @bus_free_time: I2C bus free time requirement 13885b4fab2SMaxime COQUELIN * @sda_pulse_min_limit: I2C SDA pulse mini width limit 13985b4fab2SMaxime COQUELIN */ 14085b4fab2SMaxime COQUELIN struct st_i2c_timings { 14185b4fab2SMaxime COQUELIN u32 rate; 14285b4fab2SMaxime COQUELIN u32 rep_start_hold; 14385b4fab2SMaxime COQUELIN u32 rep_start_setup; 14485b4fab2SMaxime COQUELIN u32 start_hold; 14585b4fab2SMaxime COQUELIN u32 data_setup_time; 14685b4fab2SMaxime COQUELIN u32 stop_setup_time; 14785b4fab2SMaxime COQUELIN u32 bus_free_time; 14885b4fab2SMaxime COQUELIN u32 sda_pulse_min_limit; 14985b4fab2SMaxime COQUELIN }; 15085b4fab2SMaxime COQUELIN 15185b4fab2SMaxime COQUELIN /** 15285b4fab2SMaxime COQUELIN * struct st_i2c_client - client specific data 15385b4fab2SMaxime COQUELIN * @addr: 8-bit slave addr, including r/w bit 15485b4fab2SMaxime COQUELIN * @count: number of bytes to be transfered 15585b4fab2SMaxime COQUELIN * @xfered: number of bytes already transferred 15685b4fab2SMaxime COQUELIN * @buf: data buffer 15785b4fab2SMaxime COQUELIN * @result: result of the transfer 15885b4fab2SMaxime COQUELIN * @stop: last I2C msg to be sent, i.e. STOP to be generated 15985b4fab2SMaxime COQUELIN */ 16085b4fab2SMaxime COQUELIN struct st_i2c_client { 16185b4fab2SMaxime COQUELIN u8 addr; 16285b4fab2SMaxime COQUELIN u32 count; 16385b4fab2SMaxime COQUELIN u32 xfered; 16485b4fab2SMaxime COQUELIN u8 *buf; 16585b4fab2SMaxime COQUELIN int result; 16685b4fab2SMaxime COQUELIN bool stop; 16785b4fab2SMaxime COQUELIN }; 16885b4fab2SMaxime COQUELIN 16985b4fab2SMaxime COQUELIN /** 17085b4fab2SMaxime COQUELIN * struct st_i2c_dev - private data of the controller 17185b4fab2SMaxime COQUELIN * @adap: I2C adapter for this controller 17285b4fab2SMaxime COQUELIN * @dev: device for this controller 17385b4fab2SMaxime COQUELIN * @base: virtual memory area 17485b4fab2SMaxime COQUELIN * @complete: completion of I2C message 17585b4fab2SMaxime COQUELIN * @irq: interrupt line for th controller 17685b4fab2SMaxime COQUELIN * @clk: hw ssc block clock 17785b4fab2SMaxime COQUELIN * @mode: I2C mode of the controller. Standard or Fast only supported 17885b4fab2SMaxime COQUELIN * @scl_min_width_us: SCL line minimum pulse width in us 17985b4fab2SMaxime COQUELIN * @sda_min_width_us: SDA line minimum pulse width in us 18085b4fab2SMaxime COQUELIN * @client: I2C transfert information 18185b4fab2SMaxime COQUELIN * @busy: I2C transfer on-going 18285b4fab2SMaxime COQUELIN */ 18385b4fab2SMaxime COQUELIN struct st_i2c_dev { 18485b4fab2SMaxime COQUELIN struct i2c_adapter adap; 18585b4fab2SMaxime COQUELIN struct device *dev; 18685b4fab2SMaxime COQUELIN void __iomem *base; 18785b4fab2SMaxime COQUELIN struct completion complete; 18885b4fab2SMaxime COQUELIN int irq; 18985b4fab2SMaxime COQUELIN struct clk *clk; 19085b4fab2SMaxime COQUELIN int mode; 19185b4fab2SMaxime COQUELIN u32 scl_min_width_us; 19285b4fab2SMaxime COQUELIN u32 sda_min_width_us; 19385b4fab2SMaxime COQUELIN struct st_i2c_client client; 19485b4fab2SMaxime COQUELIN bool busy; 19585b4fab2SMaxime COQUELIN }; 19685b4fab2SMaxime COQUELIN 19785b4fab2SMaxime COQUELIN static inline void st_i2c_set_bits(void __iomem *reg, u32 mask) 19885b4fab2SMaxime COQUELIN { 19985b4fab2SMaxime COQUELIN writel_relaxed(readl_relaxed(reg) | mask, reg); 20085b4fab2SMaxime COQUELIN } 20185b4fab2SMaxime COQUELIN 20285b4fab2SMaxime COQUELIN static inline void st_i2c_clr_bits(void __iomem *reg, u32 mask) 20385b4fab2SMaxime COQUELIN { 20485b4fab2SMaxime COQUELIN writel_relaxed(readl_relaxed(reg) & ~mask, reg); 20585b4fab2SMaxime COQUELIN } 20685b4fab2SMaxime COQUELIN 20752976fa7SMaxime COQUELIN /* 20852976fa7SMaxime COQUELIN * From I2C Specifications v0.5. 20952976fa7SMaxime COQUELIN * 21052976fa7SMaxime COQUELIN * All the values below have +10% margin added to be 21152976fa7SMaxime COQUELIN * compatible with some out-of-spec devices, 21252976fa7SMaxime COQUELIN * like HDMI link of the Toshiba 19AV600 TV. 21352976fa7SMaxime COQUELIN */ 21485b4fab2SMaxime COQUELIN static struct st_i2c_timings i2c_timings[] = { 21585b4fab2SMaxime COQUELIN [I2C_MODE_STANDARD] = { 21690224e64SAndy Shevchenko .rate = I2C_MAX_STANDARD_MODE_FREQ, 21752976fa7SMaxime COQUELIN .rep_start_hold = 4400, 21852976fa7SMaxime COQUELIN .rep_start_setup = 5170, 21952976fa7SMaxime COQUELIN .start_hold = 4400, 22052976fa7SMaxime COQUELIN .data_setup_time = 275, 22152976fa7SMaxime COQUELIN .stop_setup_time = 4400, 22252976fa7SMaxime COQUELIN .bus_free_time = 5170, 22385b4fab2SMaxime COQUELIN }, 22485b4fab2SMaxime COQUELIN [I2C_MODE_FAST] = { 22590224e64SAndy Shevchenko .rate = I2C_MAX_FAST_MODE_FREQ, 22652976fa7SMaxime COQUELIN .rep_start_hold = 660, 22752976fa7SMaxime COQUELIN .rep_start_setup = 660, 22852976fa7SMaxime COQUELIN .start_hold = 660, 22952976fa7SMaxime COQUELIN .data_setup_time = 110, 23052976fa7SMaxime COQUELIN .stop_setup_time = 660, 23152976fa7SMaxime COQUELIN .bus_free_time = 1430, 23285b4fab2SMaxime COQUELIN }, 23385b4fab2SMaxime COQUELIN }; 23485b4fab2SMaxime COQUELIN 23585b4fab2SMaxime COQUELIN static void st_i2c_flush_rx_fifo(struct st_i2c_dev *i2c_dev) 23685b4fab2SMaxime COQUELIN { 23785b4fab2SMaxime COQUELIN int count, i; 23885b4fab2SMaxime COQUELIN 23985b4fab2SMaxime COQUELIN /* 24085b4fab2SMaxime COQUELIN * Counter only counts up to 7 but fifo size is 8... 24185b4fab2SMaxime COQUELIN * When fifo is full, counter is 0 and RIR bit of status register is 24285b4fab2SMaxime COQUELIN * set 24385b4fab2SMaxime COQUELIN */ 24485b4fab2SMaxime COQUELIN if (readl_relaxed(i2c_dev->base + SSC_STA) & SSC_STA_RIR) 24585b4fab2SMaxime COQUELIN count = SSC_RXFIFO_SIZE; 24685b4fab2SMaxime COQUELIN else 24785b4fab2SMaxime COQUELIN count = readl_relaxed(i2c_dev->base + SSC_RX_FSTAT) & 24885b4fab2SMaxime COQUELIN SSC_RX_FSTAT_STATUS; 24985b4fab2SMaxime COQUELIN 25085b4fab2SMaxime COQUELIN for (i = 0; i < count; i++) 25185b4fab2SMaxime COQUELIN readl_relaxed(i2c_dev->base + SSC_RBUF); 25285b4fab2SMaxime COQUELIN } 25385b4fab2SMaxime COQUELIN 25485b4fab2SMaxime COQUELIN static void st_i2c_soft_reset(struct st_i2c_dev *i2c_dev) 25585b4fab2SMaxime COQUELIN { 25685b4fab2SMaxime COQUELIN /* 25785b4fab2SMaxime COQUELIN * FIFO needs to be emptied before reseting the IP, 25885b4fab2SMaxime COQUELIN * else the controller raises a BUSY error. 25985b4fab2SMaxime COQUELIN */ 26085b4fab2SMaxime COQUELIN st_i2c_flush_rx_fifo(i2c_dev); 26185b4fab2SMaxime COQUELIN 26285b4fab2SMaxime COQUELIN st_i2c_set_bits(i2c_dev->base + SSC_CTL, SSC_CTL_SR); 26385b4fab2SMaxime COQUELIN st_i2c_clr_bits(i2c_dev->base + SSC_CTL, SSC_CTL_SR); 26485b4fab2SMaxime COQUELIN } 26585b4fab2SMaxime COQUELIN 26685b4fab2SMaxime COQUELIN /** 26785b4fab2SMaxime COQUELIN * st_i2c_hw_config() - Prepare SSC block, calculate and apply tuning timings 26885b4fab2SMaxime COQUELIN * @i2c_dev: Controller's private data 26985b4fab2SMaxime COQUELIN */ 27085b4fab2SMaxime COQUELIN static void st_i2c_hw_config(struct st_i2c_dev *i2c_dev) 27185b4fab2SMaxime COQUELIN { 27285b4fab2SMaxime COQUELIN unsigned long rate; 27385b4fab2SMaxime COQUELIN u32 val, ns_per_clk; 27485b4fab2SMaxime COQUELIN struct st_i2c_timings *t = &i2c_timings[i2c_dev->mode]; 27585b4fab2SMaxime COQUELIN 27685b4fab2SMaxime COQUELIN st_i2c_soft_reset(i2c_dev); 27785b4fab2SMaxime COQUELIN 27885b4fab2SMaxime COQUELIN val = SSC_CLR_REPSTRT | SSC_CLR_NACK | SSC_CLR_SSCARBL | 27985b4fab2SMaxime COQUELIN SSC_CLR_SSCAAS | SSC_CLR_SSCSTOP; 28085b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_CLR); 28185b4fab2SMaxime COQUELIN 28285b4fab2SMaxime COQUELIN /* SSC Control register setup */ 28385b4fab2SMaxime COQUELIN val = SSC_CTL_PO | SSC_CTL_PH | SSC_CTL_HB | SSC_CTL_DATA_WIDTH_9; 28485b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_CTL); 28585b4fab2SMaxime COQUELIN 28685b4fab2SMaxime COQUELIN rate = clk_get_rate(i2c_dev->clk); 28785b4fab2SMaxime COQUELIN ns_per_clk = 1000000000 / rate; 28885b4fab2SMaxime COQUELIN 28985b4fab2SMaxime COQUELIN /* Baudrate */ 29085b4fab2SMaxime COQUELIN val = rate / (2 * t->rate); 29185b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_BRG); 29285b4fab2SMaxime COQUELIN 29385b4fab2SMaxime COQUELIN /* Pre-scaler baudrate */ 29485b4fab2SMaxime COQUELIN writel_relaxed(1, i2c_dev->base + SSC_PRE_SCALER_BRG); 29585b4fab2SMaxime COQUELIN 29685b4fab2SMaxime COQUELIN /* Enable I2C mode */ 29785b4fab2SMaxime COQUELIN writel_relaxed(SSC_I2C_I2CM, i2c_dev->base + SSC_I2C); 29885b4fab2SMaxime COQUELIN 29985b4fab2SMaxime COQUELIN /* Repeated start hold time */ 30085b4fab2SMaxime COQUELIN val = t->rep_start_hold / ns_per_clk; 30185b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_REP_START_HOLD); 30285b4fab2SMaxime COQUELIN 30385b4fab2SMaxime COQUELIN /* Repeated start set up time */ 30485b4fab2SMaxime COQUELIN val = t->rep_start_setup / ns_per_clk; 30585b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_REP_START_SETUP); 30685b4fab2SMaxime COQUELIN 30785b4fab2SMaxime COQUELIN /* Start hold time */ 30885b4fab2SMaxime COQUELIN val = t->start_hold / ns_per_clk; 30985b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_START_HOLD); 31085b4fab2SMaxime COQUELIN 31185b4fab2SMaxime COQUELIN /* Data set up time */ 31285b4fab2SMaxime COQUELIN val = t->data_setup_time / ns_per_clk; 31385b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_DATA_SETUP); 31485b4fab2SMaxime COQUELIN 31585b4fab2SMaxime COQUELIN /* Stop set up time */ 31685b4fab2SMaxime COQUELIN val = t->stop_setup_time / ns_per_clk; 31785b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_STOP_SETUP); 31885b4fab2SMaxime COQUELIN 31985b4fab2SMaxime COQUELIN /* Bus free time */ 32085b4fab2SMaxime COQUELIN val = t->bus_free_time / ns_per_clk; 32185b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_BUS_FREE); 32285b4fab2SMaxime COQUELIN 32385b4fab2SMaxime COQUELIN /* Prescalers set up */ 32485b4fab2SMaxime COQUELIN val = rate / 10000000; 32585b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_PRSCALER); 32685b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_PRSCALER_DATAOUT); 32785b4fab2SMaxime COQUELIN 32885b4fab2SMaxime COQUELIN /* Noise suppression witdh */ 32985b4fab2SMaxime COQUELIN val = i2c_dev->scl_min_width_us * rate / 100000000; 33085b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_NOISE_SUPP_WIDTH); 33185b4fab2SMaxime COQUELIN 33285b4fab2SMaxime COQUELIN /* Noise suppression max output data delay width */ 33385b4fab2SMaxime COQUELIN val = i2c_dev->sda_min_width_us * rate / 100000000; 33485b4fab2SMaxime COQUELIN writel_relaxed(val, i2c_dev->base + SSC_NOISE_SUPP_WIDTH_DATAOUT); 33585b4fab2SMaxime COQUELIN } 33685b4fab2SMaxime COQUELIN 33740027b2fSPeter Griffin static int st_i2c_recover_bus(struct i2c_adapter *i2c_adap) 33840027b2fSPeter Griffin { 33940027b2fSPeter Griffin struct st_i2c_dev *i2c_dev = i2c_get_adapdata(i2c_adap); 34040027b2fSPeter Griffin u32 ctl; 34140027b2fSPeter Griffin 34240027b2fSPeter Griffin dev_dbg(i2c_dev->dev, "Trying to recover bus\n"); 34340027b2fSPeter Griffin 34440027b2fSPeter Griffin /* 34540027b2fSPeter Griffin * SSP IP is dual role SPI/I2C to generate 9 clock pulses 34640027b2fSPeter Griffin * we switch to SPI node, 9 bit words and write a 0. This 34740027b2fSPeter Griffin * has been validate with a oscilloscope and is easier 34840027b2fSPeter Griffin * than switching to GPIO mode. 34940027b2fSPeter Griffin */ 35040027b2fSPeter Griffin 35140027b2fSPeter Griffin /* Disable interrupts */ 35240027b2fSPeter Griffin writel_relaxed(0, i2c_dev->base + SSC_IEN); 35340027b2fSPeter Griffin 35440027b2fSPeter Griffin st_i2c_hw_config(i2c_dev); 35540027b2fSPeter Griffin 35640027b2fSPeter Griffin ctl = SSC_CTL_EN | SSC_CTL_MS | SSC_CTL_EN_RX_FIFO | SSC_CTL_EN_TX_FIFO; 35740027b2fSPeter Griffin st_i2c_set_bits(i2c_dev->base + SSC_CTL, ctl); 35840027b2fSPeter Griffin 35940027b2fSPeter Griffin st_i2c_clr_bits(i2c_dev->base + SSC_I2C, SSC_I2C_I2CM); 36040027b2fSPeter Griffin usleep_range(8000, 10000); 36140027b2fSPeter Griffin 36240027b2fSPeter Griffin writel_relaxed(0, i2c_dev->base + SSC_TBUF); 36340027b2fSPeter Griffin usleep_range(2000, 4000); 36440027b2fSPeter Griffin st_i2c_set_bits(i2c_dev->base + SSC_I2C, SSC_I2C_I2CM); 36540027b2fSPeter Griffin 36640027b2fSPeter Griffin return 0; 36740027b2fSPeter Griffin } 36840027b2fSPeter Griffin 36985b4fab2SMaxime COQUELIN static int st_i2c_wait_free_bus(struct st_i2c_dev *i2c_dev) 37085b4fab2SMaxime COQUELIN { 37185b4fab2SMaxime COQUELIN u32 sta; 37240027b2fSPeter Griffin int i, ret; 37385b4fab2SMaxime COQUELIN 37485b4fab2SMaxime COQUELIN for (i = 0; i < 10; i++) { 37585b4fab2SMaxime COQUELIN sta = readl_relaxed(i2c_dev->base + SSC_STA); 37685b4fab2SMaxime COQUELIN if (!(sta & SSC_STA_BUSY)) 37785b4fab2SMaxime COQUELIN return 0; 37885b4fab2SMaxime COQUELIN 37985b4fab2SMaxime COQUELIN usleep_range(2000, 4000); 38085b4fab2SMaxime COQUELIN } 38185b4fab2SMaxime COQUELIN 38285b4fab2SMaxime COQUELIN dev_err(i2c_dev->dev, "bus not free (status = 0x%08x)\n", sta); 38385b4fab2SMaxime COQUELIN 38440027b2fSPeter Griffin ret = i2c_recover_bus(&i2c_dev->adap); 38540027b2fSPeter Griffin if (ret) { 38640027b2fSPeter Griffin dev_err(i2c_dev->dev, "Failed to recover the bus (%d)\n", ret); 38740027b2fSPeter Griffin return ret; 38840027b2fSPeter Griffin } 38940027b2fSPeter Griffin 39085b4fab2SMaxime COQUELIN return -EBUSY; 39185b4fab2SMaxime COQUELIN } 39285b4fab2SMaxime COQUELIN 39385b4fab2SMaxime COQUELIN /** 39485b4fab2SMaxime COQUELIN * st_i2c_write_tx_fifo() - Write a byte in the Tx FIFO 39585b4fab2SMaxime COQUELIN * @i2c_dev: Controller's private data 39685b4fab2SMaxime COQUELIN * @byte: Data to write in the Tx FIFO 39785b4fab2SMaxime COQUELIN */ 39885b4fab2SMaxime COQUELIN static inline void st_i2c_write_tx_fifo(struct st_i2c_dev *i2c_dev, u8 byte) 39985b4fab2SMaxime COQUELIN { 40085b4fab2SMaxime COQUELIN u16 tbuf = byte << 1; 40185b4fab2SMaxime COQUELIN 40285b4fab2SMaxime COQUELIN writel_relaxed(tbuf | 1, i2c_dev->base + SSC_TBUF); 40385b4fab2SMaxime COQUELIN } 40485b4fab2SMaxime COQUELIN 40585b4fab2SMaxime COQUELIN /** 40685b4fab2SMaxime COQUELIN * st_i2c_wr_fill_tx_fifo() - Fill the Tx FIFO in write mode 40785b4fab2SMaxime COQUELIN * @i2c_dev: Controller's private data 40885b4fab2SMaxime COQUELIN * 40985b4fab2SMaxime COQUELIN * This functions fills the Tx FIFO with I2C transfert buffer when 41085b4fab2SMaxime COQUELIN * in write mode. 41185b4fab2SMaxime COQUELIN */ 41285b4fab2SMaxime COQUELIN static void st_i2c_wr_fill_tx_fifo(struct st_i2c_dev *i2c_dev) 41385b4fab2SMaxime COQUELIN { 41485b4fab2SMaxime COQUELIN struct st_i2c_client *c = &i2c_dev->client; 41585b4fab2SMaxime COQUELIN u32 tx_fstat, sta; 41685b4fab2SMaxime COQUELIN int i; 41785b4fab2SMaxime COQUELIN 41885b4fab2SMaxime COQUELIN sta = readl_relaxed(i2c_dev->base + SSC_STA); 41985b4fab2SMaxime COQUELIN if (sta & SSC_STA_TX_FIFO_FULL) 42085b4fab2SMaxime COQUELIN return; 42185b4fab2SMaxime COQUELIN 42285b4fab2SMaxime COQUELIN tx_fstat = readl_relaxed(i2c_dev->base + SSC_TX_FSTAT); 42385b4fab2SMaxime COQUELIN tx_fstat &= SSC_TX_FSTAT_STATUS; 42485b4fab2SMaxime COQUELIN 42585b4fab2SMaxime COQUELIN if (c->count < (SSC_TXFIFO_SIZE - tx_fstat)) 42685b4fab2SMaxime COQUELIN i = c->count; 42785b4fab2SMaxime COQUELIN else 42885b4fab2SMaxime COQUELIN i = SSC_TXFIFO_SIZE - tx_fstat; 42985b4fab2SMaxime COQUELIN 43085b4fab2SMaxime COQUELIN for (; i > 0; i--, c->count--, c->buf++) 43185b4fab2SMaxime COQUELIN st_i2c_write_tx_fifo(i2c_dev, *c->buf); 43285b4fab2SMaxime COQUELIN } 43385b4fab2SMaxime COQUELIN 43485b4fab2SMaxime COQUELIN /** 43585b4fab2SMaxime COQUELIN * st_i2c_rd_fill_tx_fifo() - Fill the Tx FIFO in read mode 43685b4fab2SMaxime COQUELIN * @i2c_dev: Controller's private data 437f491c668SAlain Volmat * @max: Maximum amount of data to fill into the Tx FIFO 43885b4fab2SMaxime COQUELIN * 43985b4fab2SMaxime COQUELIN * This functions fills the Tx FIFO with fixed pattern when 44085b4fab2SMaxime COQUELIN * in read mode to trigger clock. 44185b4fab2SMaxime COQUELIN */ 44285b4fab2SMaxime COQUELIN static void st_i2c_rd_fill_tx_fifo(struct st_i2c_dev *i2c_dev, int max) 44385b4fab2SMaxime COQUELIN { 44485b4fab2SMaxime COQUELIN struct st_i2c_client *c = &i2c_dev->client; 44585b4fab2SMaxime COQUELIN u32 tx_fstat, sta; 44685b4fab2SMaxime COQUELIN int i; 44785b4fab2SMaxime COQUELIN 44885b4fab2SMaxime COQUELIN sta = readl_relaxed(i2c_dev->base + SSC_STA); 44985b4fab2SMaxime COQUELIN if (sta & SSC_STA_TX_FIFO_FULL) 45085b4fab2SMaxime COQUELIN return; 45185b4fab2SMaxime COQUELIN 45285b4fab2SMaxime COQUELIN tx_fstat = readl_relaxed(i2c_dev->base + SSC_TX_FSTAT); 45385b4fab2SMaxime COQUELIN tx_fstat &= SSC_TX_FSTAT_STATUS; 45485b4fab2SMaxime COQUELIN 45585b4fab2SMaxime COQUELIN if (max < (SSC_TXFIFO_SIZE - tx_fstat)) 45685b4fab2SMaxime COQUELIN i = max; 45785b4fab2SMaxime COQUELIN else 45885b4fab2SMaxime COQUELIN i = SSC_TXFIFO_SIZE - tx_fstat; 45985b4fab2SMaxime COQUELIN 46085b4fab2SMaxime COQUELIN for (; i > 0; i--, c->xfered++) 46185b4fab2SMaxime COQUELIN st_i2c_write_tx_fifo(i2c_dev, 0xff); 46285b4fab2SMaxime COQUELIN } 46385b4fab2SMaxime COQUELIN 46485b4fab2SMaxime COQUELIN static void st_i2c_read_rx_fifo(struct st_i2c_dev *i2c_dev) 46585b4fab2SMaxime COQUELIN { 46685b4fab2SMaxime COQUELIN struct st_i2c_client *c = &i2c_dev->client; 46785b4fab2SMaxime COQUELIN u32 i, sta; 46885b4fab2SMaxime COQUELIN u16 rbuf; 46985b4fab2SMaxime COQUELIN 47085b4fab2SMaxime COQUELIN sta = readl_relaxed(i2c_dev->base + SSC_STA); 47185b4fab2SMaxime COQUELIN if (sta & SSC_STA_RIR) { 47285b4fab2SMaxime COQUELIN i = SSC_RXFIFO_SIZE; 47385b4fab2SMaxime COQUELIN } else { 47485b4fab2SMaxime COQUELIN i = readl_relaxed(i2c_dev->base + SSC_RX_FSTAT); 47585b4fab2SMaxime COQUELIN i &= SSC_RX_FSTAT_STATUS; 47685b4fab2SMaxime COQUELIN } 47785b4fab2SMaxime COQUELIN 47885b4fab2SMaxime COQUELIN for (; (i > 0) && (c->count > 0); i--, c->count--) { 47985b4fab2SMaxime COQUELIN rbuf = readl_relaxed(i2c_dev->base + SSC_RBUF) >> 1; 48085b4fab2SMaxime COQUELIN *c->buf++ = (u8)rbuf & 0xff; 48185b4fab2SMaxime COQUELIN } 48285b4fab2SMaxime COQUELIN 48385b4fab2SMaxime COQUELIN if (i) { 48485b4fab2SMaxime COQUELIN dev_err(i2c_dev->dev, "Unexpected %d bytes in rx fifo\n", i); 48585b4fab2SMaxime COQUELIN st_i2c_flush_rx_fifo(i2c_dev); 48685b4fab2SMaxime COQUELIN } 48785b4fab2SMaxime COQUELIN } 48885b4fab2SMaxime COQUELIN 48985b4fab2SMaxime COQUELIN /** 49085b4fab2SMaxime COQUELIN * st_i2c_terminate_xfer() - Send either STOP or REPSTART condition 49185b4fab2SMaxime COQUELIN * @i2c_dev: Controller's private data 49285b4fab2SMaxime COQUELIN */ 49385b4fab2SMaxime COQUELIN static void st_i2c_terminate_xfer(struct st_i2c_dev *i2c_dev) 49485b4fab2SMaxime COQUELIN { 49585b4fab2SMaxime COQUELIN struct st_i2c_client *c = &i2c_dev->client; 49685b4fab2SMaxime COQUELIN 49785b4fab2SMaxime COQUELIN st_i2c_clr_bits(i2c_dev->base + SSC_IEN, SSC_IEN_TEEN); 49885b4fab2SMaxime COQUELIN st_i2c_clr_bits(i2c_dev->base + SSC_I2C, SSC_I2C_STRTG); 49985b4fab2SMaxime COQUELIN 50085b4fab2SMaxime COQUELIN if (c->stop) { 50185b4fab2SMaxime COQUELIN st_i2c_set_bits(i2c_dev->base + SSC_IEN, SSC_IEN_STOPEN); 50285b4fab2SMaxime COQUELIN st_i2c_set_bits(i2c_dev->base + SSC_I2C, SSC_I2C_STOPG); 50385b4fab2SMaxime COQUELIN } else { 50485b4fab2SMaxime COQUELIN st_i2c_set_bits(i2c_dev->base + SSC_IEN, SSC_IEN_REPSTRTEN); 50585b4fab2SMaxime COQUELIN st_i2c_set_bits(i2c_dev->base + SSC_I2C, SSC_I2C_REPSTRTG); 50685b4fab2SMaxime COQUELIN } 50785b4fab2SMaxime COQUELIN } 50885b4fab2SMaxime COQUELIN 50985b4fab2SMaxime COQUELIN /** 51085b4fab2SMaxime COQUELIN * st_i2c_handle_write() - Handle FIFO empty interrupt in case of write 51185b4fab2SMaxime COQUELIN * @i2c_dev: Controller's private data 51285b4fab2SMaxime COQUELIN */ 51385b4fab2SMaxime COQUELIN static void st_i2c_handle_write(struct st_i2c_dev *i2c_dev) 51485b4fab2SMaxime COQUELIN { 51585b4fab2SMaxime COQUELIN struct st_i2c_client *c = &i2c_dev->client; 51685b4fab2SMaxime COQUELIN 51785b4fab2SMaxime COQUELIN st_i2c_flush_rx_fifo(i2c_dev); 51885b4fab2SMaxime COQUELIN 51985b4fab2SMaxime COQUELIN if (!c->count) 52085b4fab2SMaxime COQUELIN /* End of xfer, send stop or repstart */ 52185b4fab2SMaxime COQUELIN st_i2c_terminate_xfer(i2c_dev); 52285b4fab2SMaxime COQUELIN else 52385b4fab2SMaxime COQUELIN st_i2c_wr_fill_tx_fifo(i2c_dev); 52485b4fab2SMaxime COQUELIN } 52585b4fab2SMaxime COQUELIN 52685b4fab2SMaxime COQUELIN /** 527721a6fe5SLee Jones * st_i2c_handle_read() - Handle FIFO empty interrupt in case of read 52885b4fab2SMaxime COQUELIN * @i2c_dev: Controller's private data 52985b4fab2SMaxime COQUELIN */ 53085b4fab2SMaxime COQUELIN static void st_i2c_handle_read(struct st_i2c_dev *i2c_dev) 53185b4fab2SMaxime COQUELIN { 53285b4fab2SMaxime COQUELIN struct st_i2c_client *c = &i2c_dev->client; 53385b4fab2SMaxime COQUELIN u32 ien; 53485b4fab2SMaxime COQUELIN 53585b4fab2SMaxime COQUELIN /* Trash the address read back */ 53685b4fab2SMaxime COQUELIN if (!c->xfered) { 53785b4fab2SMaxime COQUELIN readl_relaxed(i2c_dev->base + SSC_RBUF); 53885b4fab2SMaxime COQUELIN st_i2c_clr_bits(i2c_dev->base + SSC_I2C, SSC_I2C_TXENB); 53985b4fab2SMaxime COQUELIN } else { 54085b4fab2SMaxime COQUELIN st_i2c_read_rx_fifo(i2c_dev); 54185b4fab2SMaxime COQUELIN } 54285b4fab2SMaxime COQUELIN 54385b4fab2SMaxime COQUELIN if (!c->count) { 54485b4fab2SMaxime COQUELIN /* End of xfer, send stop or repstart */ 54585b4fab2SMaxime COQUELIN st_i2c_terminate_xfer(i2c_dev); 54685b4fab2SMaxime COQUELIN } else if (c->count == 1) { 54785b4fab2SMaxime COQUELIN /* Penultimate byte to xfer, disable ACK gen. */ 54885b4fab2SMaxime COQUELIN st_i2c_clr_bits(i2c_dev->base + SSC_I2C, SSC_I2C_ACKG); 54985b4fab2SMaxime COQUELIN 55085b4fab2SMaxime COQUELIN /* Last received byte is to be handled by NACK interrupt */ 55185b4fab2SMaxime COQUELIN ien = SSC_IEN_NACKEN | SSC_IEN_ARBLEN; 55285b4fab2SMaxime COQUELIN writel_relaxed(ien, i2c_dev->base + SSC_IEN); 55385b4fab2SMaxime COQUELIN 55485b4fab2SMaxime COQUELIN st_i2c_rd_fill_tx_fifo(i2c_dev, c->count); 55585b4fab2SMaxime COQUELIN } else { 55685b4fab2SMaxime COQUELIN st_i2c_rd_fill_tx_fifo(i2c_dev, c->count - 1); 55785b4fab2SMaxime COQUELIN } 55885b4fab2SMaxime COQUELIN } 55985b4fab2SMaxime COQUELIN 56085b4fab2SMaxime COQUELIN /** 561721a6fe5SLee Jones * st_i2c_isr_thread() - Interrupt routine 56285b4fab2SMaxime COQUELIN * @irq: interrupt number 56385b4fab2SMaxime COQUELIN * @data: Controller's private data 56485b4fab2SMaxime COQUELIN */ 56585b4fab2SMaxime COQUELIN static irqreturn_t st_i2c_isr_thread(int irq, void *data) 56685b4fab2SMaxime COQUELIN { 56785b4fab2SMaxime COQUELIN struct st_i2c_dev *i2c_dev = data; 56885b4fab2SMaxime COQUELIN struct st_i2c_client *c = &i2c_dev->client; 56985b4fab2SMaxime COQUELIN u32 sta, ien; 57085b4fab2SMaxime COQUELIN int it; 57185b4fab2SMaxime COQUELIN 57285b4fab2SMaxime COQUELIN ien = readl_relaxed(i2c_dev->base + SSC_IEN); 57385b4fab2SMaxime COQUELIN sta = readl_relaxed(i2c_dev->base + SSC_STA); 57485b4fab2SMaxime COQUELIN 57585b4fab2SMaxime COQUELIN /* Use __fls() to check error bits first */ 57685b4fab2SMaxime COQUELIN it = __fls(sta & ien); 57785b4fab2SMaxime COQUELIN if (it < 0) { 57885b4fab2SMaxime COQUELIN dev_dbg(i2c_dev->dev, "spurious it (sta=0x%04x, ien=0x%04x)\n", 57985b4fab2SMaxime COQUELIN sta, ien); 58085b4fab2SMaxime COQUELIN return IRQ_NONE; 58185b4fab2SMaxime COQUELIN } 58285b4fab2SMaxime COQUELIN 58385b4fab2SMaxime COQUELIN switch (1 << it) { 58485b4fab2SMaxime COQUELIN case SSC_STA_TE: 58585b4fab2SMaxime COQUELIN if (c->addr & I2C_M_RD) 58685b4fab2SMaxime COQUELIN st_i2c_handle_read(i2c_dev); 58785b4fab2SMaxime COQUELIN else 58885b4fab2SMaxime COQUELIN st_i2c_handle_write(i2c_dev); 58985b4fab2SMaxime COQUELIN break; 59085b4fab2SMaxime COQUELIN 59185b4fab2SMaxime COQUELIN case SSC_STA_STOP: 59285b4fab2SMaxime COQUELIN case SSC_STA_REPSTRT: 59385b4fab2SMaxime COQUELIN writel_relaxed(0, i2c_dev->base + SSC_IEN); 59485b4fab2SMaxime COQUELIN complete(&i2c_dev->complete); 59585b4fab2SMaxime COQUELIN break; 59685b4fab2SMaxime COQUELIN 59785b4fab2SMaxime COQUELIN case SSC_STA_NACK: 59885b4fab2SMaxime COQUELIN writel_relaxed(SSC_CLR_NACK, i2c_dev->base + SSC_CLR); 59985b4fab2SMaxime COQUELIN 60085b4fab2SMaxime COQUELIN /* Last received byte handled by NACK interrupt */ 60185b4fab2SMaxime COQUELIN if ((c->addr & I2C_M_RD) && (c->count == 1) && (c->xfered)) { 60285b4fab2SMaxime COQUELIN st_i2c_handle_read(i2c_dev); 60385b4fab2SMaxime COQUELIN break; 60485b4fab2SMaxime COQUELIN } 60585b4fab2SMaxime COQUELIN 60685b4fab2SMaxime COQUELIN it = SSC_IEN_STOPEN | SSC_IEN_ARBLEN; 60785b4fab2SMaxime COQUELIN writel_relaxed(it, i2c_dev->base + SSC_IEN); 60885b4fab2SMaxime COQUELIN 60985b4fab2SMaxime COQUELIN st_i2c_set_bits(i2c_dev->base + SSC_I2C, SSC_I2C_STOPG); 61085b4fab2SMaxime COQUELIN c->result = -EIO; 61185b4fab2SMaxime COQUELIN break; 61285b4fab2SMaxime COQUELIN 61385b4fab2SMaxime COQUELIN case SSC_STA_ARBL: 61485b4fab2SMaxime COQUELIN writel_relaxed(SSC_CLR_SSCARBL, i2c_dev->base + SSC_CLR); 61585b4fab2SMaxime COQUELIN 61685b4fab2SMaxime COQUELIN it = SSC_IEN_STOPEN | SSC_IEN_ARBLEN; 61785b4fab2SMaxime COQUELIN writel_relaxed(it, i2c_dev->base + SSC_IEN); 61885b4fab2SMaxime COQUELIN 61985b4fab2SMaxime COQUELIN st_i2c_set_bits(i2c_dev->base + SSC_I2C, SSC_I2C_STOPG); 6204fda9962SMaxime COQUELIN c->result = -EAGAIN; 62185b4fab2SMaxime COQUELIN break; 62285b4fab2SMaxime COQUELIN 62385b4fab2SMaxime COQUELIN default: 62485b4fab2SMaxime COQUELIN dev_err(i2c_dev->dev, 62585b4fab2SMaxime COQUELIN "it %d unhandled (sta=0x%04x)\n", it, sta); 62685b4fab2SMaxime COQUELIN } 62785b4fab2SMaxime COQUELIN 62885b4fab2SMaxime COQUELIN /* 62985b4fab2SMaxime COQUELIN * Read IEN register to ensure interrupt mask write is effective 63085b4fab2SMaxime COQUELIN * before re-enabling interrupt at GIC level, and thus avoid spurious 63185b4fab2SMaxime COQUELIN * interrupts. 63285b4fab2SMaxime COQUELIN */ 63385b4fab2SMaxime COQUELIN readl(i2c_dev->base + SSC_IEN); 63485b4fab2SMaxime COQUELIN 63585b4fab2SMaxime COQUELIN return IRQ_HANDLED; 63685b4fab2SMaxime COQUELIN } 63785b4fab2SMaxime COQUELIN 63885b4fab2SMaxime COQUELIN /** 63985b4fab2SMaxime COQUELIN * st_i2c_xfer_msg() - Transfer a single I2C message 64085b4fab2SMaxime COQUELIN * @i2c_dev: Controller's private data 64185b4fab2SMaxime COQUELIN * @msg: I2C message to transfer 64285b4fab2SMaxime COQUELIN * @is_first: first message of the sequence 64385b4fab2SMaxime COQUELIN * @is_last: last message of the sequence 64485b4fab2SMaxime COQUELIN */ 64585b4fab2SMaxime COQUELIN static int st_i2c_xfer_msg(struct st_i2c_dev *i2c_dev, struct i2c_msg *msg, 64685b4fab2SMaxime COQUELIN bool is_first, bool is_last) 64785b4fab2SMaxime COQUELIN { 64885b4fab2SMaxime COQUELIN struct st_i2c_client *c = &i2c_dev->client; 64985b4fab2SMaxime COQUELIN u32 ctl, i2c, it; 65085b4fab2SMaxime COQUELIN unsigned long timeout; 65185b4fab2SMaxime COQUELIN int ret; 65285b4fab2SMaxime COQUELIN 653a51a79d5SWolfram Sang c->addr = i2c_8bit_addr_from_msg(msg); 65485b4fab2SMaxime COQUELIN c->buf = msg->buf; 65585b4fab2SMaxime COQUELIN c->count = msg->len; 65685b4fab2SMaxime COQUELIN c->xfered = 0; 65785b4fab2SMaxime COQUELIN c->result = 0; 65885b4fab2SMaxime COQUELIN c->stop = is_last; 65985b4fab2SMaxime COQUELIN 66013509c3aSLinus Torvalds reinit_completion(&i2c_dev->complete); 66185b4fab2SMaxime COQUELIN 66285b4fab2SMaxime COQUELIN ctl = SSC_CTL_EN | SSC_CTL_MS | SSC_CTL_EN_RX_FIFO | SSC_CTL_EN_TX_FIFO; 66385b4fab2SMaxime COQUELIN st_i2c_set_bits(i2c_dev->base + SSC_CTL, ctl); 66485b4fab2SMaxime COQUELIN 66585b4fab2SMaxime COQUELIN i2c = SSC_I2C_TXENB; 66685b4fab2SMaxime COQUELIN if (c->addr & I2C_M_RD) 66785b4fab2SMaxime COQUELIN i2c |= SSC_I2C_ACKG; 66885b4fab2SMaxime COQUELIN st_i2c_set_bits(i2c_dev->base + SSC_I2C, i2c); 66985b4fab2SMaxime COQUELIN 67085b4fab2SMaxime COQUELIN /* Write slave address */ 67185b4fab2SMaxime COQUELIN st_i2c_write_tx_fifo(i2c_dev, c->addr); 67285b4fab2SMaxime COQUELIN 67385b4fab2SMaxime COQUELIN /* Pre-fill Tx fifo with data in case of write */ 67485b4fab2SMaxime COQUELIN if (!(c->addr & I2C_M_RD)) 67585b4fab2SMaxime COQUELIN st_i2c_wr_fill_tx_fifo(i2c_dev); 67685b4fab2SMaxime COQUELIN 67785b4fab2SMaxime COQUELIN it = SSC_IEN_NACKEN | SSC_IEN_TEEN | SSC_IEN_ARBLEN; 67885b4fab2SMaxime COQUELIN writel_relaxed(it, i2c_dev->base + SSC_IEN); 67985b4fab2SMaxime COQUELIN 68085b4fab2SMaxime COQUELIN if (is_first) { 68185b4fab2SMaxime COQUELIN ret = st_i2c_wait_free_bus(i2c_dev); 68285b4fab2SMaxime COQUELIN if (ret) 68385b4fab2SMaxime COQUELIN return ret; 68485b4fab2SMaxime COQUELIN 68585b4fab2SMaxime COQUELIN st_i2c_set_bits(i2c_dev->base + SSC_I2C, SSC_I2C_STRTG); 68685b4fab2SMaxime COQUELIN } 68785b4fab2SMaxime COQUELIN 68885b4fab2SMaxime COQUELIN timeout = wait_for_completion_timeout(&i2c_dev->complete, 68985b4fab2SMaxime COQUELIN i2c_dev->adap.timeout); 69085b4fab2SMaxime COQUELIN ret = c->result; 69185b4fab2SMaxime COQUELIN 69285b4fab2SMaxime COQUELIN if (!timeout) { 69385b4fab2SMaxime COQUELIN dev_err(i2c_dev->dev, "Write to slave 0x%x timed out\n", 69485b4fab2SMaxime COQUELIN c->addr); 69585b4fab2SMaxime COQUELIN ret = -ETIMEDOUT; 69685b4fab2SMaxime COQUELIN } 69785b4fab2SMaxime COQUELIN 69885b4fab2SMaxime COQUELIN i2c = SSC_I2C_STOPG | SSC_I2C_REPSTRTG; 69985b4fab2SMaxime COQUELIN st_i2c_clr_bits(i2c_dev->base + SSC_I2C, i2c); 70085b4fab2SMaxime COQUELIN 70185b4fab2SMaxime COQUELIN writel_relaxed(SSC_CLR_SSCSTOP | SSC_CLR_REPSTRT, 70285b4fab2SMaxime COQUELIN i2c_dev->base + SSC_CLR); 70385b4fab2SMaxime COQUELIN 70485b4fab2SMaxime COQUELIN return ret; 70585b4fab2SMaxime COQUELIN } 70685b4fab2SMaxime COQUELIN 70785b4fab2SMaxime COQUELIN /** 70885b4fab2SMaxime COQUELIN * st_i2c_xfer() - Transfer a single I2C message 70985b4fab2SMaxime COQUELIN * @i2c_adap: Adapter pointer to the controller 71085b4fab2SMaxime COQUELIN * @msgs: Pointer to data to be written. 71185b4fab2SMaxime COQUELIN * @num: Number of messages to be executed 71285b4fab2SMaxime COQUELIN */ 71385b4fab2SMaxime COQUELIN static int st_i2c_xfer(struct i2c_adapter *i2c_adap, 71485b4fab2SMaxime COQUELIN struct i2c_msg msgs[], int num) 71585b4fab2SMaxime COQUELIN { 71685b4fab2SMaxime COQUELIN struct st_i2c_dev *i2c_dev = i2c_get_adapdata(i2c_adap); 71785b4fab2SMaxime COQUELIN int ret, i; 71885b4fab2SMaxime COQUELIN 71985b4fab2SMaxime COQUELIN i2c_dev->busy = true; 72085b4fab2SMaxime COQUELIN 72185b4fab2SMaxime COQUELIN ret = clk_prepare_enable(i2c_dev->clk); 72285b4fab2SMaxime COQUELIN if (ret) { 72385b4fab2SMaxime COQUELIN dev_err(i2c_dev->dev, "Failed to prepare_enable clock\n"); 72485b4fab2SMaxime COQUELIN return ret; 72585b4fab2SMaxime COQUELIN } 72685b4fab2SMaxime COQUELIN 72785b4fab2SMaxime COQUELIN pinctrl_pm_select_default_state(i2c_dev->dev); 72885b4fab2SMaxime COQUELIN 72985b4fab2SMaxime COQUELIN st_i2c_hw_config(i2c_dev); 73085b4fab2SMaxime COQUELIN 73185b4fab2SMaxime COQUELIN for (i = 0; (i < num) && !ret; i++) 73285b4fab2SMaxime COQUELIN ret = st_i2c_xfer_msg(i2c_dev, &msgs[i], i == 0, i == num - 1); 73385b4fab2SMaxime COQUELIN 73485b4fab2SMaxime COQUELIN pinctrl_pm_select_idle_state(i2c_dev->dev); 73585b4fab2SMaxime COQUELIN 73685b4fab2SMaxime COQUELIN clk_disable_unprepare(i2c_dev->clk); 73785b4fab2SMaxime COQUELIN 73885b4fab2SMaxime COQUELIN i2c_dev->busy = false; 73985b4fab2SMaxime COQUELIN 74085b4fab2SMaxime COQUELIN return (ret < 0) ? ret : i; 74185b4fab2SMaxime COQUELIN } 74285b4fab2SMaxime COQUELIN 74385b4fab2SMaxime COQUELIN static int st_i2c_suspend(struct device *dev) 74485b4fab2SMaxime COQUELIN { 7459242e72aSMasahiro Yamada struct st_i2c_dev *i2c_dev = dev_get_drvdata(dev); 74685b4fab2SMaxime COQUELIN 74785b4fab2SMaxime COQUELIN if (i2c_dev->busy) 74885b4fab2SMaxime COQUELIN return -EBUSY; 74985b4fab2SMaxime COQUELIN 75085b4fab2SMaxime COQUELIN pinctrl_pm_select_sleep_state(dev); 75185b4fab2SMaxime COQUELIN 75285b4fab2SMaxime COQUELIN return 0; 75385b4fab2SMaxime COQUELIN } 75485b4fab2SMaxime COQUELIN 75585b4fab2SMaxime COQUELIN static int st_i2c_resume(struct device *dev) 75685b4fab2SMaxime COQUELIN { 75785b4fab2SMaxime COQUELIN pinctrl_pm_select_default_state(dev); 75885b4fab2SMaxime COQUELIN /* Go in idle state if available */ 75985b4fab2SMaxime COQUELIN pinctrl_pm_select_idle_state(dev); 76085b4fab2SMaxime COQUELIN 76185b4fab2SMaxime COQUELIN return 0; 76285b4fab2SMaxime COQUELIN } 76385b4fab2SMaxime COQUELIN 764fce55da3SAlain Volmat static DEFINE_SIMPLE_DEV_PM_OPS(st_i2c_pm, st_i2c_suspend, st_i2c_resume); 76585b4fab2SMaxime COQUELIN 76685b4fab2SMaxime COQUELIN static u32 st_i2c_func(struct i2c_adapter *adap) 76785b4fab2SMaxime COQUELIN { 76885b4fab2SMaxime COQUELIN return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; 76985b4fab2SMaxime COQUELIN } 77085b4fab2SMaxime COQUELIN 77192d9d0dfSBhumika Goyal static const struct i2c_algorithm st_i2c_algo = { 77285b4fab2SMaxime COQUELIN .master_xfer = st_i2c_xfer, 77385b4fab2SMaxime COQUELIN .functionality = st_i2c_func, 77485b4fab2SMaxime COQUELIN }; 77585b4fab2SMaxime COQUELIN 77640027b2fSPeter Griffin static struct i2c_bus_recovery_info st_i2c_recovery_info = { 77740027b2fSPeter Griffin .recover_bus = st_i2c_recover_bus, 77840027b2fSPeter Griffin }; 77940027b2fSPeter Griffin 78085b4fab2SMaxime COQUELIN static int st_i2c_of_get_deglitch(struct device_node *np, 78185b4fab2SMaxime COQUELIN struct st_i2c_dev *i2c_dev) 78285b4fab2SMaxime COQUELIN { 78385b4fab2SMaxime COQUELIN int ret; 78485b4fab2SMaxime COQUELIN 78585b4fab2SMaxime COQUELIN ret = of_property_read_u32(np, "st,i2c-min-scl-pulse-width-us", 78685b4fab2SMaxime COQUELIN &i2c_dev->scl_min_width_us); 78785b4fab2SMaxime COQUELIN if ((ret == -ENODATA) || (ret == -EOVERFLOW)) { 78885b4fab2SMaxime COQUELIN dev_err(i2c_dev->dev, "st,i2c-min-scl-pulse-width-us invalid\n"); 78985b4fab2SMaxime COQUELIN return ret; 79085b4fab2SMaxime COQUELIN } 79185b4fab2SMaxime COQUELIN 79285b4fab2SMaxime COQUELIN ret = of_property_read_u32(np, "st,i2c-min-sda-pulse-width-us", 79385b4fab2SMaxime COQUELIN &i2c_dev->sda_min_width_us); 79485b4fab2SMaxime COQUELIN if ((ret == -ENODATA) || (ret == -EOVERFLOW)) { 79585b4fab2SMaxime COQUELIN dev_err(i2c_dev->dev, "st,i2c-min-sda-pulse-width-us invalid\n"); 79685b4fab2SMaxime COQUELIN return ret; 79785b4fab2SMaxime COQUELIN } 79885b4fab2SMaxime COQUELIN 79985b4fab2SMaxime COQUELIN return 0; 80085b4fab2SMaxime COQUELIN } 80185b4fab2SMaxime COQUELIN 80285b4fab2SMaxime COQUELIN static int st_i2c_probe(struct platform_device *pdev) 80385b4fab2SMaxime COQUELIN { 80485b4fab2SMaxime COQUELIN struct device_node *np = pdev->dev.of_node; 80585b4fab2SMaxime COQUELIN struct st_i2c_dev *i2c_dev; 80685b4fab2SMaxime COQUELIN struct resource *res; 80785b4fab2SMaxime COQUELIN u32 clk_rate; 80885b4fab2SMaxime COQUELIN struct i2c_adapter *adap; 80985b4fab2SMaxime COQUELIN int ret; 81085b4fab2SMaxime COQUELIN 81185b4fab2SMaxime COQUELIN i2c_dev = devm_kzalloc(&pdev->dev, sizeof(*i2c_dev), GFP_KERNEL); 81285b4fab2SMaxime COQUELIN if (!i2c_dev) 81385b4fab2SMaxime COQUELIN return -ENOMEM; 81485b4fab2SMaxime COQUELIN 81585b4fab2SMaxime COQUELIN res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 81685b4fab2SMaxime COQUELIN i2c_dev->base = devm_ioremap_resource(&pdev->dev, res); 81785b4fab2SMaxime COQUELIN if (IS_ERR(i2c_dev->base)) 81885b4fab2SMaxime COQUELIN return PTR_ERR(i2c_dev->base); 81985b4fab2SMaxime COQUELIN 82085b4fab2SMaxime COQUELIN i2c_dev->irq = irq_of_parse_and_map(np, 0); 82185b4fab2SMaxime COQUELIN if (!i2c_dev->irq) { 82285b4fab2SMaxime COQUELIN dev_err(&pdev->dev, "IRQ missing or invalid\n"); 82385b4fab2SMaxime COQUELIN return -EINVAL; 82485b4fab2SMaxime COQUELIN } 82585b4fab2SMaxime COQUELIN 82685b4fab2SMaxime COQUELIN i2c_dev->clk = of_clk_get_by_name(np, "ssc"); 82785b4fab2SMaxime COQUELIN if (IS_ERR(i2c_dev->clk)) { 82885b4fab2SMaxime COQUELIN dev_err(&pdev->dev, "Unable to request clock\n"); 82985b4fab2SMaxime COQUELIN return PTR_ERR(i2c_dev->clk); 83085b4fab2SMaxime COQUELIN } 83185b4fab2SMaxime COQUELIN 83285b4fab2SMaxime COQUELIN i2c_dev->mode = I2C_MODE_STANDARD; 83385b4fab2SMaxime COQUELIN ret = of_property_read_u32(np, "clock-frequency", &clk_rate); 83490224e64SAndy Shevchenko if (!ret && (clk_rate == I2C_MAX_FAST_MODE_FREQ)) 83585b4fab2SMaxime COQUELIN i2c_dev->mode = I2C_MODE_FAST; 83685b4fab2SMaxime COQUELIN 83785b4fab2SMaxime COQUELIN i2c_dev->dev = &pdev->dev; 83885b4fab2SMaxime COQUELIN 83985b4fab2SMaxime COQUELIN ret = devm_request_threaded_irq(&pdev->dev, i2c_dev->irq, 84085b4fab2SMaxime COQUELIN NULL, st_i2c_isr_thread, 84185b4fab2SMaxime COQUELIN IRQF_ONESHOT, pdev->name, i2c_dev); 84285b4fab2SMaxime COQUELIN if (ret) { 84385b4fab2SMaxime COQUELIN dev_err(&pdev->dev, "Failed to request irq %i\n", i2c_dev->irq); 84485b4fab2SMaxime COQUELIN return ret; 84585b4fab2SMaxime COQUELIN } 84685b4fab2SMaxime COQUELIN 84785b4fab2SMaxime COQUELIN pinctrl_pm_select_default_state(i2c_dev->dev); 84885b4fab2SMaxime COQUELIN /* In case idle state available, select it */ 84985b4fab2SMaxime COQUELIN pinctrl_pm_select_idle_state(i2c_dev->dev); 85085b4fab2SMaxime COQUELIN 85185b4fab2SMaxime COQUELIN ret = st_i2c_of_get_deglitch(np, i2c_dev); 85285b4fab2SMaxime COQUELIN if (ret) 85385b4fab2SMaxime COQUELIN return ret; 85485b4fab2SMaxime COQUELIN 85585b4fab2SMaxime COQUELIN adap = &i2c_dev->adap; 85685b4fab2SMaxime COQUELIN i2c_set_adapdata(adap, i2c_dev); 857a07f0ad7SDmitry V. Krivenok snprintf(adap->name, sizeof(adap->name), "ST I2C(%pa)", &res->start); 85885b4fab2SMaxime COQUELIN adap->owner = THIS_MODULE; 85985b4fab2SMaxime COQUELIN adap->timeout = 2 * HZ; 86085b4fab2SMaxime COQUELIN adap->retries = 0; 86185b4fab2SMaxime COQUELIN adap->algo = &st_i2c_algo; 86240027b2fSPeter Griffin adap->bus_recovery_info = &st_i2c_recovery_info; 86385b4fab2SMaxime COQUELIN adap->dev.parent = &pdev->dev; 86485b4fab2SMaxime COQUELIN adap->dev.of_node = pdev->dev.of_node; 86585b4fab2SMaxime COQUELIN 86685b4fab2SMaxime COQUELIN init_completion(&i2c_dev->complete); 86785b4fab2SMaxime COQUELIN 86885b4fab2SMaxime COQUELIN ret = i2c_add_adapter(adap); 869ea734404SWolfram Sang if (ret) 87085b4fab2SMaxime COQUELIN return ret; 87185b4fab2SMaxime COQUELIN 87285b4fab2SMaxime COQUELIN platform_set_drvdata(pdev, i2c_dev); 87385b4fab2SMaxime COQUELIN 87485b4fab2SMaxime COQUELIN dev_info(i2c_dev->dev, "%s initialized\n", adap->name); 87585b4fab2SMaxime COQUELIN 87685b4fab2SMaxime COQUELIN return 0; 87785b4fab2SMaxime COQUELIN } 87885b4fab2SMaxime COQUELIN 879*e190a0c3SUwe Kleine-König static void st_i2c_remove(struct platform_device *pdev) 88085b4fab2SMaxime COQUELIN { 88185b4fab2SMaxime COQUELIN struct st_i2c_dev *i2c_dev = platform_get_drvdata(pdev); 88285b4fab2SMaxime COQUELIN 88385b4fab2SMaxime COQUELIN i2c_del_adapter(&i2c_dev->adap); 88485b4fab2SMaxime COQUELIN } 88585b4fab2SMaxime COQUELIN 886eae45e5dSJingoo Han static const struct of_device_id st_i2c_match[] = { 88785b4fab2SMaxime COQUELIN { .compatible = "st,comms-ssc-i2c", }, 88885b4fab2SMaxime COQUELIN { .compatible = "st,comms-ssc4-i2c", }, 88985b4fab2SMaxime COQUELIN {}, 89085b4fab2SMaxime COQUELIN }; 89185b4fab2SMaxime COQUELIN MODULE_DEVICE_TABLE(of, st_i2c_match); 89285b4fab2SMaxime COQUELIN 89385b4fab2SMaxime COQUELIN static struct platform_driver st_i2c_driver = { 89485b4fab2SMaxime COQUELIN .driver = { 89585b4fab2SMaxime COQUELIN .name = "st-i2c", 89685b4fab2SMaxime COQUELIN .of_match_table = st_i2c_match, 897fce55da3SAlain Volmat .pm = pm_sleep_ptr(&st_i2c_pm), 89885b4fab2SMaxime COQUELIN }, 89985b4fab2SMaxime COQUELIN .probe = st_i2c_probe, 900*e190a0c3SUwe Kleine-König .remove_new = st_i2c_remove, 90185b4fab2SMaxime COQUELIN }; 90285b4fab2SMaxime COQUELIN 90385b4fab2SMaxime COQUELIN module_platform_driver(st_i2c_driver); 90485b4fab2SMaxime COQUELIN 90585b4fab2SMaxime COQUELIN MODULE_AUTHOR("Maxime Coquelin <maxime.coquelin@st.com>"); 90685b4fab2SMaxime COQUELIN MODULE_DESCRIPTION("STMicroelectronics I2C driver"); 90785b4fab2SMaxime COQUELIN MODULE_LICENSE("GPL v2"); 908