1 /* 2 * SuperH Mobile I2C Controller 3 * 4 * Copyright (C) 2008 Magnus Damm 5 * 6 * Portions of the code based on out-of-tree driver i2c-sh7343.c 7 * Copyright (c) 2006 Carlos Munoz <carlos@kenati.com> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 */ 22 23 #include <linux/kernel.h> 24 #include <linux/module.h> 25 #include <linux/init.h> 26 #include <linux/delay.h> 27 #include <linux/platform_device.h> 28 #include <linux/interrupt.h> 29 #include <linux/i2c.h> 30 #include <linux/err.h> 31 #include <linux/clk.h> 32 #include <linux/io.h> 33 34 enum sh_mobile_i2c_op { 35 OP_START = 0, 36 OP_TX_ONLY, 37 OP_TX_STOP, 38 OP_TX_TO_RX, 39 OP_RX_ONLY, 40 OP_RX_STOP, 41 }; 42 43 struct sh_mobile_i2c_data { 44 struct device *dev; 45 void __iomem *reg; 46 struct i2c_adapter adap; 47 48 struct clk *clk; 49 u_int8_t iccl; 50 u_int8_t icch; 51 52 spinlock_t lock; 53 wait_queue_head_t wait; 54 struct i2c_msg *msg; 55 int pos; 56 int sr; 57 }; 58 59 #define NORMAL_SPEED 100000 /* FAST_SPEED 400000 */ 60 61 /* Register offsets */ 62 #define ICDR(pd) (pd->reg + 0x00) 63 #define ICCR(pd) (pd->reg + 0x04) 64 #define ICSR(pd) (pd->reg + 0x08) 65 #define ICIC(pd) (pd->reg + 0x0c) 66 #define ICCL(pd) (pd->reg + 0x10) 67 #define ICCH(pd) (pd->reg + 0x14) 68 69 /* Register bits */ 70 #define ICCR_ICE 0x80 71 #define ICCR_RACK 0x40 72 #define ICCR_TRS 0x10 73 #define ICCR_BBSY 0x04 74 #define ICCR_SCP 0x01 75 76 #define ICSR_SCLM 0x80 77 #define ICSR_SDAM 0x40 78 #define SW_DONE 0x20 79 #define ICSR_BUSY 0x10 80 #define ICSR_AL 0x08 81 #define ICSR_TACK 0x04 82 #define ICSR_WAIT 0x02 83 #define ICSR_DTE 0x01 84 85 #define ICIC_ALE 0x08 86 #define ICIC_TACKE 0x04 87 #define ICIC_WAITE 0x02 88 #define ICIC_DTEE 0x01 89 90 static void activate_ch(struct sh_mobile_i2c_data *pd) 91 { 92 /* Make sure the clock is enabled */ 93 clk_enable(pd->clk); 94 95 /* Enable channel and configure rx ack */ 96 iowrite8(ioread8(ICCR(pd)) | ICCR_ICE, ICCR(pd)); 97 98 /* Mask all interrupts */ 99 iowrite8(0, ICIC(pd)); 100 101 /* Set the clock */ 102 iowrite8(pd->iccl, ICCL(pd)); 103 iowrite8(pd->icch, ICCH(pd)); 104 } 105 106 static void deactivate_ch(struct sh_mobile_i2c_data *pd) 107 { 108 /* Clear/disable interrupts */ 109 iowrite8(0, ICSR(pd)); 110 iowrite8(0, ICIC(pd)); 111 112 /* Disable channel */ 113 iowrite8(ioread8(ICCR(pd)) & ~ICCR_ICE, ICCR(pd)); 114 115 /* Disable clock */ 116 clk_disable(pd->clk); 117 } 118 119 static unsigned char i2c_op(struct sh_mobile_i2c_data *pd, 120 enum sh_mobile_i2c_op op, unsigned char data) 121 { 122 unsigned char ret = 0; 123 unsigned long flags; 124 125 dev_dbg(pd->dev, "op %d, data in 0x%02x\n", op, data); 126 127 spin_lock_irqsave(&pd->lock, flags); 128 129 switch (op) { 130 case OP_START: 131 iowrite8(0x94, ICCR(pd)); 132 break; 133 case OP_TX_ONLY: 134 iowrite8(data, ICDR(pd)); 135 break; 136 case OP_TX_STOP: 137 iowrite8(data, ICDR(pd)); 138 iowrite8(0x90, ICCR(pd)); 139 iowrite8(ICIC_ALE | ICIC_TACKE, ICIC(pd)); 140 break; 141 case OP_TX_TO_RX: 142 iowrite8(data, ICDR(pd)); 143 iowrite8(0x81, ICCR(pd)); 144 break; 145 case OP_RX_ONLY: 146 ret = ioread8(ICDR(pd)); 147 break; 148 case OP_RX_STOP: 149 ret = ioread8(ICDR(pd)); 150 iowrite8(0xc0, ICCR(pd)); 151 break; 152 } 153 154 spin_unlock_irqrestore(&pd->lock, flags); 155 156 dev_dbg(pd->dev, "op %d, data out 0x%02x\n", op, ret); 157 return ret; 158 } 159 160 static irqreturn_t sh_mobile_i2c_isr(int irq, void *dev_id) 161 { 162 struct platform_device *dev = dev_id; 163 struct sh_mobile_i2c_data *pd = platform_get_drvdata(dev); 164 struct i2c_msg *msg = pd->msg; 165 unsigned char data, sr; 166 int wakeup = 0; 167 168 sr = ioread8(ICSR(pd)); 169 pd->sr |= sr; 170 171 dev_dbg(pd->dev, "i2c_isr 0x%02x 0x%02x %s %d %d!\n", sr, pd->sr, 172 (msg->flags & I2C_M_RD) ? "read" : "write", 173 pd->pos, msg->len); 174 175 if (sr & (ICSR_AL | ICSR_TACK)) { 176 iowrite8(0, ICIC(pd)); /* disable interrupts */ 177 wakeup = 1; 178 goto do_wakeup; 179 } 180 181 if (pd->pos == msg->len) { 182 i2c_op(pd, OP_RX_ONLY, 0); 183 wakeup = 1; 184 goto do_wakeup; 185 } 186 187 if (pd->pos == -1) { 188 data = (msg->addr & 0x7f) << 1; 189 data |= (msg->flags & I2C_M_RD) ? 1 : 0; 190 } else 191 data = msg->buf[pd->pos]; 192 193 if ((pd->pos == -1) || !(msg->flags & I2C_M_RD)) { 194 if (msg->flags & I2C_M_RD) 195 i2c_op(pd, OP_TX_TO_RX, data); 196 else if (pd->pos == (msg->len - 1)) { 197 i2c_op(pd, OP_TX_STOP, data); 198 wakeup = 1; 199 } else 200 i2c_op(pd, OP_TX_ONLY, data); 201 } else { 202 if (pd->pos == (msg->len - 1)) 203 data = i2c_op(pd, OP_RX_STOP, 0); 204 else 205 data = i2c_op(pd, OP_RX_ONLY, 0); 206 207 msg->buf[pd->pos] = data; 208 } 209 pd->pos++; 210 211 do_wakeup: 212 if (wakeup) { 213 pd->sr |= SW_DONE; 214 wake_up(&pd->wait); 215 } 216 217 return IRQ_HANDLED; 218 } 219 220 static int start_ch(struct sh_mobile_i2c_data *pd, struct i2c_msg *usr_msg) 221 { 222 /* Initialize channel registers */ 223 iowrite8(ioread8(ICCR(pd)) & ~ICCR_ICE, ICCR(pd)); 224 225 /* Enable channel and configure rx ack */ 226 iowrite8(ioread8(ICCR(pd)) | ICCR_ICE, ICCR(pd)); 227 228 /* Set the clock */ 229 iowrite8(pd->iccl, ICCL(pd)); 230 iowrite8(pd->icch, ICCH(pd)); 231 232 pd->msg = usr_msg; 233 pd->pos = -1; 234 pd->sr = 0; 235 236 /* Enable all interrupts except wait */ 237 iowrite8(ioread8(ICIC(pd)) | ICIC_ALE | ICIC_TACKE | ICIC_DTEE, 238 ICIC(pd)); 239 return 0; 240 } 241 242 static int sh_mobile_i2c_xfer(struct i2c_adapter *adapter, 243 struct i2c_msg *msgs, 244 int num) 245 { 246 struct sh_mobile_i2c_data *pd = i2c_get_adapdata(adapter); 247 struct i2c_msg *msg; 248 int err = 0; 249 u_int8_t val; 250 int i, k, retry_count; 251 252 activate_ch(pd); 253 254 /* Process all messages */ 255 for (i = 0; i < num; i++) { 256 msg = &msgs[i]; 257 258 err = start_ch(pd, msg); 259 if (err) 260 break; 261 262 i2c_op(pd, OP_START, 0); 263 264 /* The interrupt handler takes care of the rest... */ 265 k = wait_event_timeout(pd->wait, 266 pd->sr & (ICSR_TACK | SW_DONE), 267 5 * HZ); 268 if (!k) 269 dev_err(pd->dev, "Transfer request timed out\n"); 270 271 retry_count = 10; 272 again: 273 val = ioread8(ICSR(pd)); 274 275 dev_dbg(pd->dev, "val 0x%02x pd->sr 0x%02x\n", val, pd->sr); 276 277 if ((val | pd->sr) & (ICSR_TACK | ICSR_AL)) { 278 err = -EIO; 279 break; 280 } 281 282 /* the interrupt handler may wake us up before the 283 * transfer is finished, so poll the hardware 284 * until we're done. 285 */ 286 287 if (!(!(val & ICSR_BUSY) && (val & ICSR_SCLM) && 288 (val & ICSR_SDAM))) { 289 msleep(1); 290 if (retry_count--) 291 goto again; 292 293 err = -EIO; 294 dev_err(pd->dev, "Polling timed out\n"); 295 break; 296 } 297 } 298 299 deactivate_ch(pd); 300 301 if (!err) 302 err = num; 303 return err; 304 } 305 306 static u32 sh_mobile_i2c_func(struct i2c_adapter *adapter) 307 { 308 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; 309 } 310 311 static struct i2c_algorithm sh_mobile_i2c_algorithm = { 312 .functionality = sh_mobile_i2c_func, 313 .master_xfer = sh_mobile_i2c_xfer, 314 }; 315 316 static void sh_mobile_i2c_setup_channel(struct platform_device *dev) 317 { 318 struct sh_mobile_i2c_data *pd = platform_get_drvdata(dev); 319 unsigned long peripheral_clk = clk_get_rate(pd->clk); 320 u_int32_t num; 321 u_int32_t denom; 322 u_int32_t tmp; 323 324 spin_lock_init(&pd->lock); 325 init_waitqueue_head(&pd->wait); 326 327 /* Calculate the value for iccl. From the data sheet: 328 * iccl = (p clock / transfer rate) * (L / (L + H)) 329 * where L and H are the SCL low/high ratio (5/4 in this case). 330 * We also round off the result. 331 */ 332 num = peripheral_clk * 5; 333 denom = NORMAL_SPEED * 9; 334 tmp = num * 10 / denom; 335 if (tmp % 10 >= 5) 336 pd->iccl = (u_int8_t)((num/denom) + 1); 337 else 338 pd->iccl = (u_int8_t)(num/denom); 339 340 /* Calculate the value for icch. From the data sheet: 341 icch = (p clock / transfer rate) * (H / (L + H)) */ 342 num = peripheral_clk * 4; 343 tmp = num * 10 / denom; 344 if (tmp % 10 >= 5) 345 pd->icch = (u_int8_t)((num/denom) + 1); 346 else 347 pd->icch = (u_int8_t)(num/denom); 348 } 349 350 static int sh_mobile_i2c_hook_irqs(struct platform_device *dev, int hook) 351 { 352 struct resource *res; 353 int ret = -ENXIO; 354 int q, m; 355 int k = 0; 356 int n = 0; 357 358 while ((res = platform_get_resource(dev, IORESOURCE_IRQ, k))) { 359 for (n = res->start; hook && n <= res->end; n++) { 360 if (request_irq(n, sh_mobile_i2c_isr, IRQF_DISABLED, 361 dev->dev.bus_id, dev)) 362 goto rollback; 363 } 364 k++; 365 } 366 367 if (hook) 368 return k > 0 ? 0 : -ENOENT; 369 370 k--; 371 ret = 0; 372 373 rollback: 374 for (q = k; k >= 0; k--) { 375 for (m = n; m >= res->start; m--) 376 free_irq(m, dev); 377 378 res = platform_get_resource(dev, IORESOURCE_IRQ, k - 1); 379 m = res->end; 380 } 381 382 return ret; 383 } 384 385 static int sh_mobile_i2c_probe(struct platform_device *dev) 386 { 387 struct sh_mobile_i2c_data *pd; 388 struct i2c_adapter *adap; 389 struct resource *res; 390 int size; 391 int ret; 392 393 pd = kzalloc(sizeof(struct sh_mobile_i2c_data), GFP_KERNEL); 394 if (pd == NULL) { 395 dev_err(&dev->dev, "cannot allocate private data\n"); 396 return -ENOMEM; 397 } 398 399 pd->clk = clk_get(&dev->dev, "peripheral_clk"); 400 if (IS_ERR(pd->clk)) { 401 dev_err(&dev->dev, "cannot get peripheral clock\n"); 402 ret = PTR_ERR(pd->clk); 403 goto err; 404 } 405 406 ret = sh_mobile_i2c_hook_irqs(dev, 1); 407 if (ret) { 408 dev_err(&dev->dev, "cannot request IRQ\n"); 409 goto err_clk; 410 } 411 412 pd->dev = &dev->dev; 413 platform_set_drvdata(dev, pd); 414 415 res = platform_get_resource(dev, IORESOURCE_MEM, 0); 416 if (res == NULL) { 417 dev_err(&dev->dev, "cannot find IO resource\n"); 418 ret = -ENOENT; 419 goto err_irq; 420 } 421 422 size = (res->end - res->start) + 1; 423 424 pd->reg = ioremap(res->start, size); 425 if (pd->reg == NULL) { 426 dev_err(&dev->dev, "cannot map IO\n"); 427 ret = -ENXIO; 428 goto err_irq; 429 } 430 431 /* setup the private data */ 432 adap = &pd->adap; 433 i2c_set_adapdata(adap, pd); 434 435 adap->owner = THIS_MODULE; 436 adap->algo = &sh_mobile_i2c_algorithm; 437 adap->dev.parent = &dev->dev; 438 adap->retries = 5; 439 adap->nr = dev->id; 440 441 strlcpy(adap->name, dev->name, sizeof(adap->name)); 442 443 sh_mobile_i2c_setup_channel(dev); 444 445 ret = i2c_add_numbered_adapter(adap); 446 if (ret < 0) { 447 dev_err(&dev->dev, "cannot add numbered adapter\n"); 448 goto err_all; 449 } 450 451 return 0; 452 453 err_all: 454 iounmap(pd->reg); 455 err_irq: 456 sh_mobile_i2c_hook_irqs(dev, 0); 457 err_clk: 458 clk_put(pd->clk); 459 err: 460 kfree(pd); 461 return ret; 462 } 463 464 static int sh_mobile_i2c_remove(struct platform_device *dev) 465 { 466 struct sh_mobile_i2c_data *pd = platform_get_drvdata(dev); 467 468 i2c_del_adapter(&pd->adap); 469 iounmap(pd->reg); 470 sh_mobile_i2c_hook_irqs(dev, 0); 471 clk_put(pd->clk); 472 kfree(pd); 473 return 0; 474 } 475 476 static struct platform_driver sh_mobile_i2c_driver = { 477 .driver = { 478 .name = "i2c-sh_mobile", 479 .owner = THIS_MODULE, 480 }, 481 .probe = sh_mobile_i2c_probe, 482 .remove = sh_mobile_i2c_remove, 483 }; 484 485 static int __init sh_mobile_i2c_adap_init(void) 486 { 487 return platform_driver_register(&sh_mobile_i2c_driver); 488 } 489 490 static void __exit sh_mobile_i2c_adap_exit(void) 491 { 492 platform_driver_unregister(&sh_mobile_i2c_driver); 493 } 494 495 module_init(sh_mobile_i2c_adap_init); 496 module_exit(sh_mobile_i2c_adap_exit); 497 498 MODULE_DESCRIPTION("SuperH Mobile I2C Bus Controller driver"); 499 MODULE_AUTHOR("Magnus Damm"); 500 MODULE_LICENSE("GPL v2"); 501