drivers/i2c/sh_i2c.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2011, 2013 Renesas Solutions Corp.
   4  * Copyright (C) 2011, 2013 Nobuhiro Iwamatsu <nobuhiro.iwamatsu.yj@renesas.com>
   5  *
   6  * NOTE: This driver should be converted to driver model before June 2017.
   7  * Please see doc/driver-model/i2c-howto.rst for instructions.
   8  */
   9
  10 #include <common.h>
  11 #include <i2c.h>
  12 #include <log.h>
  13 #include <asm/io.h>
  14 #include <linux/delay.h>
  15
  16 DECLARE_GLOBAL_DATA_PTR;
  17
  18 /* Every register is 32bit aligned, but only 8bits in size */
  19 #define ureg(name) u8 name; u8 __pad_##name##0; u16 __pad_##name##1;
  20 struct sh_i2c {
  21         ureg(icdr);
  22         ureg(iccr);
  23         ureg(icsr);
  24         ureg(icic);
  25         ureg(iccl);
  26         ureg(icch);
  27 };
  28 #undef ureg
  29
  30 /* ICCR */
  31 #define SH_I2C_ICCR_ICE         (1 << 7)
  32 #define SH_I2C_ICCR_RACK        (1 << 6)
  33 #define SH_I2C_ICCR_RTS         (1 << 4)
  34 #define SH_I2C_ICCR_BUSY        (1 << 2)
  35 #define SH_I2C_ICCR_SCP         (1 << 0)
  36
  37 /* ICSR / ICIC */
  38 #define SH_IC_BUSY      (1 << 4)
  39 #define SH_IC_TACK      (1 << 2)
  40 #define SH_IC_WAIT      (1 << 1)
  41 #define SH_IC_DTE       (1 << 0)
  42
  43 #ifdef CONFIG_SH_I2C_8BIT
  44 /* store 8th bit of iccl and icch in ICIC register */
  45 #define SH_I2C_ICIC_ICCLB8      (1 << 7)
  46 #define SH_I2C_ICIC_ICCHB8      (1 << 6)
  47 #endif
  48
  49 static const struct sh_i2c *i2c_dev[CONFIG_SYS_I2C_SH_NUM_CONTROLLERS] = {
  50         (struct sh_i2c *)CONFIG_SYS_I2C_SH_BASE0,
  51 #ifdef CONFIG_SYS_I2C_SH_BASE1
  52         (struct sh_i2c *)CONFIG_SYS_I2C_SH_BASE1,
  53 #endif
  54 #ifdef CONFIG_SYS_I2C_SH_BASE2
  55         (struct sh_i2c *)CONFIG_SYS_I2C_SH_BASE2,
  56 #endif
  57 #ifdef CONFIG_SYS_I2C_SH_BASE3
  58         (struct sh_i2c *)CONFIG_SYS_I2C_SH_BASE3,
  59 #endif
  60 #ifdef CONFIG_SYS_I2C_SH_BASE4
  61         (struct sh_i2c *)CONFIG_SYS_I2C_SH_BASE4,
  62 #endif
  63 };
  64
  65 static u16 iccl, icch;
  66
  67 #define IRQ_WAIT 1000
  68
  69 static void sh_irq_dte(struct sh_i2c *dev)
  70 {
  71         int i;
  72
  73         for (i = 0; i < IRQ_WAIT; i++) {
  74                 if (SH_IC_DTE & readb(&dev->icsr))
  75                         break;
  76                 udelay(10);
  77         }
  78 }
  79
  80 static int sh_irq_dte_with_tack(struct sh_i2c *dev)
  81 {
  82         int i;
  83
  84         for (i = 0; i < IRQ_WAIT; i++) {
  85                 if (SH_IC_DTE & readb(&dev->icsr))
  86                         break;
  87                 if (SH_IC_TACK & readb(&dev->icsr))
  88                         return -1;
  89                 udelay(10);
  90         }
  91         return 0;
  92 }
  93
  94 static void sh_irq_busy(struct sh_i2c *dev)
  95 {
  96         int i;
  97
  98         for (i = 0; i < IRQ_WAIT; i++) {
  99                 if (!(SH_IC_BUSY & readb(&dev->icsr)))
 100                         break;
 101                 udelay(10);
 102         }
 103 }
 104
 105 static int sh_i2c_set_addr(struct sh_i2c *dev, u8 chip, u8 addr, int stop)
 106 {
 107         u8 icic = SH_IC_TACK;
 108
 109         debug("%s: chip: %x, addr: %x iccl: %x, icch %x\n",
 110                                 __func__, chip, addr, iccl, icch);
 111         clrbits_8(&dev->iccr, SH_I2C_ICCR_ICE);
 112         setbits_8(&dev->iccr, SH_I2C_ICCR_ICE);
 113
 114         writeb(iccl & 0xff, &dev->iccl);
 115         writeb(icch & 0xff, &dev->icch);
 116 #ifdef CONFIG_SH_I2C_8BIT
 117         if (iccl > 0xff)
 118                 icic |= SH_I2C_ICIC_ICCLB8;
 119         if (icch > 0xff)
 120                 icic |= SH_I2C_ICIC_ICCHB8;
 121 #endif
 122         writeb(icic, &dev->icic);
 123
 124         writeb((SH_I2C_ICCR_ICE|SH_I2C_ICCR_RTS|SH_I2C_ICCR_BUSY), &dev->iccr);
 125         sh_irq_dte(dev);
 126
 127         clrbits_8(&dev->icsr, SH_IC_TACK);
 128         writeb(chip << 1, &dev->icdr);
 129         if (sh_irq_dte_with_tack(dev) != 0)
 130                 return -1;
 131
 132         writeb(addr, &dev->icdr);
 133         if (stop)
 134                 writeb((SH_I2C_ICCR_ICE|SH_I2C_ICCR_RTS), &dev->iccr);
 135
 136         if (sh_irq_dte_with_tack(dev) != 0)
 137                 return -1;
 138         return 0;
 139 }
 140
 141 static void sh_i2c_finish(struct sh_i2c *dev)
 142 {
 143         writeb(0, &dev->icsr);
 144         clrbits_8(&dev->iccr, SH_I2C_ICCR_ICE);
 145 }
 146
 147 static int
 148 sh_i2c_raw_write(struct sh_i2c *dev, u8 chip, uint addr, u8 val)
 149 {
 150         int ret = -1;
 151         if (sh_i2c_set_addr(dev, chip, addr, 0) != 0)
 152                 goto exit0;
 153         udelay(10);
 154
 155         writeb(val, &dev->icdr);
 156         if (sh_irq_dte_with_tack(dev) != 0)
 157                 goto exit0;
 158
 159         writeb((SH_I2C_ICCR_ICE | SH_I2C_ICCR_RTS), &dev->iccr);
 160         if (sh_irq_dte_with_tack(dev) != 0)
 161                 goto exit0;
 162         sh_irq_busy(dev);
 163         ret = 0;
 164
 165 exit0:
 166         sh_i2c_finish(dev);
 167         return ret;
 168 }
 169
 170 static int sh_i2c_raw_read(struct sh_i2c *dev, u8 chip, u8 addr)
 171 {
 172         int ret = -1;
 173
 174 #if defined(CONFIG_SH73A0)
 175         if (sh_i2c_set_addr(dev, chip, addr, 0) != 0)
 176                 goto exit0;
 177 #else
 178         if (sh_i2c_set_addr(dev, chip, addr, 1) != 0)
 179                 goto exit0;
 180         udelay(100);
 181 #endif
 182
 183         writeb((SH_I2C_ICCR_ICE|SH_I2C_ICCR_RTS|SH_I2C_ICCR_BUSY), &dev->iccr);
 184         sh_irq_dte(dev);
 185
 186         writeb(chip << 1 | 0x01, &dev->icdr);
 187         if (sh_irq_dte_with_tack(dev) != 0)
 188                 goto exit0;
 189
 190         writeb((SH_I2C_ICCR_ICE|SH_I2C_ICCR_SCP), &dev->iccr);
 191         if (sh_irq_dte_with_tack(dev) != 0)
 192                 goto exit0;
 193
 194         ret = readb(&dev->icdr) & 0xff;
 195
 196         writeb((SH_I2C_ICCR_ICE|SH_I2C_ICCR_RACK), &dev->iccr);
 197         readb(&dev->icdr); /* Dummy read */
 198         sh_irq_busy(dev);
 199
 200 exit0:
 201         sh_i2c_finish(dev);
 202
 203         return ret;
 204 }
 205
 206 static void
 207 sh_i2c_init(struct i2c_adapter *adap, int speed, int slaveadd)
 208 {
 209         int num, denom, tmp;
 210
 211         /* No i2c support prior to relocation */
 212         if (!(gd->flags & GD_FLG_RELOC))
 213                 return;
 214
 215         /*
 216          * Calculate the value for iccl. From the data sheet:
 217          * iccl = (p-clock / transfer-rate) * (L / (L + H))
 218          * where L and H are the SCL low and high ratio.
 219          */
 220         num = CONFIG_SH_I2C_CLOCK * CONFIG_SH_I2C_DATA_LOW;
 221         denom = speed * (CONFIG_SH_I2C_DATA_HIGH + CONFIG_SH_I2C_DATA_LOW);
 222         tmp = num * 10 / denom;
 223         if (tmp % 10 >= 5)
 224                 iccl = (u16)((num/denom) + 1);
 225         else
 226                 iccl = (u16)(num/denom);
 227
 228         /* Calculate the value for icch. From the data sheet:
 229            icch = (p clock / transfer rate) * (H / (L + H)) */
 230         num = CONFIG_SH_I2C_CLOCK * CONFIG_SH_I2C_DATA_HIGH;
 231         tmp = num * 10 / denom;
 232         if (tmp % 10 >= 5)
 233                 icch = (u16)((num/denom) + 1);
 234         else
 235                 icch = (u16)(num/denom);
 236
 237         debug("clock: %d, speed %d, iccl: %x, icch: %x\n",
 238                         CONFIG_SH_I2C_CLOCK, speed, iccl, icch);
 239 }
 240
 241 static int sh_i2c_read(struct i2c_adapter *adap, uint8_t chip,
 242                                 uint addr, int alen, u8 *data, int len)
 243 {
 244         int ret, i;
 245         struct sh_i2c *dev = (struct sh_i2c *)i2c_dev[adap->hwadapnr];
 246
 247         for (i = 0; i < len; i++) {
 248                 ret = sh_i2c_raw_read(dev, chip, addr + i);
 249                 if (ret < 0)
 250                         return -1;
 251
 252                 data[i] = ret & 0xff;
 253                 debug("%s: data[%d]: %02x\n", __func__, i, data[i]);
 254         }
 255
 256         return 0;
 257 }
 258
 259 static int sh_i2c_write(struct i2c_adapter *adap, uint8_t chip, uint addr,
 260                                 int alen, u8 *data, int len)
 261 {
 262         struct sh_i2c *dev = (struct sh_i2c *)i2c_dev[adap->hwadapnr];
 263         int i;
 264
 265         for (i = 0; i < len; i++) {
 266                 debug("%s: data[%d]: %02x\n", __func__, i, data[i]);
 267                 if (sh_i2c_raw_write(dev, chip, addr + i, data[i]) != 0)
 268                         return -1;
 269         }
 270         return 0;
 271 }
 272
 273 static int
 274 sh_i2c_probe(struct i2c_adapter *adap, u8 dev)
 275 {
 276         u8 dummy[1];
 277
 278         return sh_i2c_read(adap, dev, 0, 0, dummy, sizeof dummy);
 279 }
 280
 281 static unsigned int sh_i2c_set_bus_speed(struct i2c_adapter *adap,
 282                         unsigned int speed)
 283 {
 284         struct sh_i2c *dev = (struct sh_i2c *)i2c_dev[adap->hwadapnr];
 285
 286         sh_i2c_finish(dev);
 287         sh_i2c_init(adap, speed, 0);
 288
 289         return 0;
 290 }
 291
 292 /*
 293  * Register RCAR i2c adapters
 294  */
 295 U_BOOT_I2C_ADAP_COMPLETE(sh_0, sh_i2c_init, sh_i2c_probe, sh_i2c_read,
 296         sh_i2c_write, sh_i2c_set_bus_speed, CONFIG_SYS_I2C_SH_SPEED0, 0, 0)
 297 #ifdef CONFIG_SYS_I2C_SH_BASE1
 298 U_BOOT_I2C_ADAP_COMPLETE(sh_1, sh_i2c_init, sh_i2c_probe, sh_i2c_read,
 299         sh_i2c_write, sh_i2c_set_bus_speed, CONFIG_SYS_I2C_SH_SPEED1, 0, 1)
 300 #endif
 301 #ifdef CONFIG_SYS_I2C_SH_BASE2
 302 U_BOOT_I2C_ADAP_COMPLETE(sh_2, sh_i2c_init, sh_i2c_probe, sh_i2c_read,
 303         sh_i2c_write, sh_i2c_set_bus_speed, CONFIG_SYS_I2C_SH_SPEED2, 0, 2)
 304 #endif
 305 #ifdef CONFIG_SYS_I2C_SH_BASE3
 306 U_BOOT_I2C_ADAP_COMPLETE(sh_3, sh_i2c_init, sh_i2c_probe, sh_i2c_read,
 307         sh_i2c_write, sh_i2c_set_bus_speed, CONFIG_SYS_I2C_SH_SPEED3, 0, 3)
 308 #endif
 309 #ifdef CONFIG_SYS_I2C_SH_BASE4
 310 U_BOOT_I2C_ADAP_COMPLETE(sh_4, sh_i2c_init, sh_i2c_probe, sh_i2c_read,
 311         sh_i2c_write, sh_i2c_set_bus_speed, CONFIG_SYS_I2C_SH_SPEED4, 0, 4)
 312 #endif