1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * I2C bus driver for Conexant Digicolor SoCs 4 * 5 * Author: Baruch Siach <baruch@tkos.co.il> 6 * 7 * Copyright (C) 2015 Paradox Innovation Ltd. 8 */ 9 10 #include <linux/clk.h> 11 #include <linux/completion.h> 12 #include <linux/delay.h> 13 #include <linux/i2c.h> 14 #include <linux/interrupt.h> 15 #include <linux/io.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/of.h> 19 #include <linux/platform_device.h> 20 21 #define TIMEOUT_MS 100 22 23 #define II_CONTROL 0x0 24 #define II_CONTROL_LOCAL_RESET BIT(0) 25 26 #define II_CLOCKTIME 0x1 27 28 #define II_COMMAND 0x2 29 #define II_CMD_START 1 30 #define II_CMD_RESTART 2 31 #define II_CMD_SEND_ACK 3 32 #define II_CMD_GET_ACK 6 33 #define II_CMD_GET_NOACK 7 34 #define II_CMD_STOP 10 35 #define II_COMMAND_GO BIT(7) 36 #define II_COMMAND_COMPLETION_STATUS(r) (((r) >> 5) & 3) 37 #define II_CMD_STATUS_NORMAL 0 38 #define II_CMD_STATUS_ACK_GOOD 1 39 #define II_CMD_STATUS_ACK_BAD 2 40 #define II_CMD_STATUS_ABORT 3 41 42 #define II_DATA 0x3 43 #define II_INTFLAG_CLEAR 0x8 44 #define II_INTENABLE 0xa 45 46 struct dc_i2c { 47 struct i2c_adapter adap; 48 struct device *dev; 49 void __iomem *regs; 50 struct clk *clk; 51 unsigned int frequency; 52 53 struct i2c_msg *msg; 54 unsigned int msgbuf_ptr; 55 int last; 56 spinlock_t lock; 57 struct completion done; 58 int state; 59 int error; 60 }; 61 62 enum { 63 STATE_IDLE, 64 STATE_START, 65 STATE_ADDR, 66 STATE_WRITE, 67 STATE_READ, 68 STATE_STOP, 69 }; 70 71 static void dc_i2c_cmd(struct dc_i2c *i2c, u8 cmd) 72 { 73 writeb_relaxed(cmd | II_COMMAND_GO, i2c->regs + II_COMMAND); 74 } 75 76 static u8 dc_i2c_addr_cmd(struct i2c_msg *msg) 77 { 78 u8 addr = (msg->addr & 0x7f) << 1; 79 80 if (msg->flags & I2C_M_RD) 81 addr |= 1; 82 83 return addr; 84 } 85 86 static void dc_i2c_data(struct dc_i2c *i2c, u8 data) 87 { 88 writeb_relaxed(data, i2c->regs + II_DATA); 89 } 90 91 static void dc_i2c_write_byte(struct dc_i2c *i2c, u8 byte) 92 { 93 dc_i2c_data(i2c, byte); 94 dc_i2c_cmd(i2c, II_CMD_SEND_ACK); 95 } 96 97 static void dc_i2c_write_buf(struct dc_i2c *i2c) 98 { 99 dc_i2c_write_byte(i2c, i2c->msg->buf[i2c->msgbuf_ptr++]); 100 } 101 102 static void dc_i2c_next_read(struct dc_i2c *i2c) 103 { 104 bool last = (i2c->msgbuf_ptr + 1 == i2c->msg->len); 105 106 dc_i2c_cmd(i2c, last ? II_CMD_GET_NOACK : II_CMD_GET_ACK); 107 } 108 109 static void dc_i2c_stop(struct dc_i2c *i2c) 110 { 111 i2c->state = STATE_STOP; 112 if (i2c->last) 113 dc_i2c_cmd(i2c, II_CMD_STOP); 114 else 115 complete(&i2c->done); 116 } 117 118 static u8 dc_i2c_read_byte(struct dc_i2c *i2c) 119 { 120 return readb_relaxed(i2c->regs + II_DATA); 121 } 122 123 static void dc_i2c_read_buf(struct dc_i2c *i2c) 124 { 125 i2c->msg->buf[i2c->msgbuf_ptr++] = dc_i2c_read_byte(i2c); 126 dc_i2c_next_read(i2c); 127 } 128 129 static void dc_i2c_set_irq(struct dc_i2c *i2c, int enable) 130 { 131 if (enable) 132 writeb_relaxed(1, i2c->regs + II_INTFLAG_CLEAR); 133 writeb_relaxed(!!enable, i2c->regs + II_INTENABLE); 134 } 135 136 static int dc_i2c_cmd_status(struct dc_i2c *i2c) 137 { 138 u8 cmd = readb_relaxed(i2c->regs + II_COMMAND); 139 140 return II_COMMAND_COMPLETION_STATUS(cmd); 141 } 142 143 static void dc_i2c_start_msg(struct dc_i2c *i2c, int first) 144 { 145 struct i2c_msg *msg = i2c->msg; 146 147 if (!(msg->flags & I2C_M_NOSTART)) { 148 i2c->state = STATE_START; 149 dc_i2c_cmd(i2c, first ? II_CMD_START : II_CMD_RESTART); 150 } else if (msg->flags & I2C_M_RD) { 151 i2c->state = STATE_READ; 152 dc_i2c_next_read(i2c); 153 } else { 154 i2c->state = STATE_WRITE; 155 dc_i2c_write_buf(i2c); 156 } 157 } 158 159 static irqreturn_t dc_i2c_irq(int irq, void *dev_id) 160 { 161 struct dc_i2c *i2c = dev_id; 162 int cmd_status = dc_i2c_cmd_status(i2c); 163 u8 addr_cmd; 164 165 writeb_relaxed(1, i2c->regs + II_INTFLAG_CLEAR); 166 167 spin_lock(&i2c->lock); 168 169 if (cmd_status == II_CMD_STATUS_ACK_BAD 170 || cmd_status == II_CMD_STATUS_ABORT) { 171 i2c->error = -EIO; 172 complete(&i2c->done); 173 goto out; 174 } 175 176 switch (i2c->state) { 177 case STATE_START: 178 addr_cmd = dc_i2c_addr_cmd(i2c->msg); 179 dc_i2c_write_byte(i2c, addr_cmd); 180 i2c->state = STATE_ADDR; 181 break; 182 case STATE_ADDR: 183 if (i2c->msg->flags & I2C_M_RD) { 184 dc_i2c_next_read(i2c); 185 i2c->state = STATE_READ; 186 break; 187 } 188 i2c->state = STATE_WRITE; 189 fallthrough; 190 case STATE_WRITE: 191 if (i2c->msgbuf_ptr < i2c->msg->len) 192 dc_i2c_write_buf(i2c); 193 else 194 dc_i2c_stop(i2c); 195 break; 196 case STATE_READ: 197 if (i2c->msgbuf_ptr < i2c->msg->len) 198 dc_i2c_read_buf(i2c); 199 else 200 dc_i2c_stop(i2c); 201 break; 202 case STATE_STOP: 203 i2c->state = STATE_IDLE; 204 complete(&i2c->done); 205 break; 206 } 207 208 out: 209 spin_unlock(&i2c->lock); 210 return IRQ_HANDLED; 211 } 212 213 static int dc_i2c_xfer_msg(struct dc_i2c *i2c, struct i2c_msg *msg, int first, 214 int last) 215 { 216 unsigned long timeout = msecs_to_jiffies(TIMEOUT_MS); 217 unsigned long flags; 218 219 spin_lock_irqsave(&i2c->lock, flags); 220 i2c->msg = msg; 221 i2c->msgbuf_ptr = 0; 222 i2c->last = last; 223 i2c->error = 0; 224 225 reinit_completion(&i2c->done); 226 dc_i2c_set_irq(i2c, 1); 227 dc_i2c_start_msg(i2c, first); 228 spin_unlock_irqrestore(&i2c->lock, flags); 229 230 timeout = wait_for_completion_timeout(&i2c->done, timeout); 231 dc_i2c_set_irq(i2c, 0); 232 if (timeout == 0) { 233 i2c->state = STATE_IDLE; 234 return -ETIMEDOUT; 235 } 236 237 if (i2c->error) 238 return i2c->error; 239 240 return 0; 241 } 242 243 static int dc_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num) 244 { 245 struct dc_i2c *i2c = adap->algo_data; 246 int i, ret; 247 248 for (i = 0; i < num; i++) { 249 ret = dc_i2c_xfer_msg(i2c, &msgs[i], i == 0, i == num - 1); 250 if (ret) 251 return ret; 252 } 253 254 return num; 255 } 256 257 static int dc_i2c_init_hw(struct dc_i2c *i2c) 258 { 259 unsigned long clk_rate = clk_get_rate(i2c->clk); 260 unsigned int clocktime; 261 262 writeb_relaxed(II_CONTROL_LOCAL_RESET, i2c->regs + II_CONTROL); 263 udelay(100); 264 writeb_relaxed(0, i2c->regs + II_CONTROL); 265 udelay(100); 266 267 clocktime = DIV_ROUND_UP(clk_rate, 64 * i2c->frequency); 268 if (clocktime < 1 || clocktime > 0xff) { 269 dev_err(i2c->dev, "can't set bus speed of %u Hz\n", 270 i2c->frequency); 271 return -EINVAL; 272 } 273 writeb_relaxed(clocktime - 1, i2c->regs + II_CLOCKTIME); 274 275 return 0; 276 } 277 278 static u32 dc_i2c_func(struct i2c_adapter *adap) 279 { 280 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_NOSTART; 281 } 282 283 static const struct i2c_algorithm dc_i2c_algorithm = { 284 .master_xfer = dc_i2c_xfer, 285 .functionality = dc_i2c_func, 286 }; 287 288 static int dc_i2c_probe(struct platform_device *pdev) 289 { 290 struct device_node *np = pdev->dev.of_node; 291 struct dc_i2c *i2c; 292 int ret = 0, irq; 293 294 i2c = devm_kzalloc(&pdev->dev, sizeof(struct dc_i2c), GFP_KERNEL); 295 if (!i2c) 296 return -ENOMEM; 297 298 if (of_property_read_u32(pdev->dev.of_node, "clock-frequency", 299 &i2c->frequency)) 300 i2c->frequency = I2C_MAX_STANDARD_MODE_FREQ; 301 302 i2c->dev = &pdev->dev; 303 platform_set_drvdata(pdev, i2c); 304 305 spin_lock_init(&i2c->lock); 306 init_completion(&i2c->done); 307 308 i2c->clk = devm_clk_get(&pdev->dev, NULL); 309 if (IS_ERR(i2c->clk)) 310 return PTR_ERR(i2c->clk); 311 312 i2c->regs = devm_platform_ioremap_resource(pdev, 0); 313 if (IS_ERR(i2c->regs)) 314 return PTR_ERR(i2c->regs); 315 316 irq = platform_get_irq(pdev, 0); 317 if (irq < 0) 318 return irq; 319 320 ret = devm_request_irq(&pdev->dev, irq, dc_i2c_irq, 0, 321 dev_name(&pdev->dev), i2c); 322 if (ret < 0) 323 return ret; 324 325 strscpy(i2c->adap.name, "Conexant Digicolor I2C adapter", 326 sizeof(i2c->adap.name)); 327 i2c->adap.owner = THIS_MODULE; 328 i2c->adap.algo = &dc_i2c_algorithm; 329 i2c->adap.dev.parent = &pdev->dev; 330 i2c->adap.dev.of_node = np; 331 i2c->adap.algo_data = i2c; 332 333 ret = dc_i2c_init_hw(i2c); 334 if (ret) 335 return ret; 336 337 ret = clk_prepare_enable(i2c->clk); 338 if (ret < 0) 339 return ret; 340 341 ret = i2c_add_adapter(&i2c->adap); 342 if (ret < 0) { 343 clk_disable_unprepare(i2c->clk); 344 return ret; 345 } 346 347 return 0; 348 } 349 350 static int dc_i2c_remove(struct platform_device *pdev) 351 { 352 struct dc_i2c *i2c = platform_get_drvdata(pdev); 353 354 i2c_del_adapter(&i2c->adap); 355 clk_disable_unprepare(i2c->clk); 356 357 return 0; 358 } 359 360 static const struct of_device_id dc_i2c_match[] = { 361 { .compatible = "cnxt,cx92755-i2c" }, 362 { }, 363 }; 364 MODULE_DEVICE_TABLE(of, dc_i2c_match); 365 366 static struct platform_driver dc_i2c_driver = { 367 .probe = dc_i2c_probe, 368 .remove = dc_i2c_remove, 369 .driver = { 370 .name = "digicolor-i2c", 371 .of_match_table = dc_i2c_match, 372 }, 373 }; 374 module_platform_driver(dc_i2c_driver); 375 376 MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>"); 377 MODULE_DESCRIPTION("Conexant Digicolor I2C master driver"); 378 MODULE_LICENSE("GPL v2"); 379