drivers/i2c/busses/i2c-rk30-adapter.c

   1 /* drivers/i2c/busses/i2c-rk30-adapter.c
   2  *
   3  * Copyright (C) 2012 ROCKCHIP, Inc.
   4  *
   5  * This software is licensed under the terms of the GNU General Public
   6  * License version 2, as published by the Free Software Foundation, and
   7  * may be copied, distributed, and modified under those terms.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  */
  15 #include "i2c-rk30.h"
  16
  17 /* Control register */
  18 #define I2C_CON                 0x000
  19 #define I2C_CON_EN              (1 << 0)
  20 #define I2C_CON_MOD(mod)        ((mod) << 1)
  21 #define I2C_CON_MASK            (3 << 1)
  22 enum{
  23     I2C_CON_MOD_TX = 0,
  24     I2C_CON_MOD_TRX,
  25     I2C_CON_MOD_RX,
  26     I2C_CON_MOD_RRX,
  27 };
  28 #define I2C_CON_START           (1 << 3)
  29 #define I2C_CON_STOP            (1 << 4)
  30 #define I2C_CON_LASTACK         (1 << 5)
  31 #define I2C_CON_ACTACK          (1 << 6)
  32
  33 /* Clock dividor register */
  34 #define I2C_CLKDIV              0x004
  35 #define I2C_CLKDIV_VAL(divl, divh) (((divl) & 0xffff) | (((divh) << 16) & 0xffff0000))
  36
  37 /* the slave address accessed  for master rx mode */
  38 #define I2C_MRXADDR             0x008
  39 #define I2C_MRXADDR_LOW         (1 << 24)
  40 #define I2C_MRXADDR_MID         (1 << 25)
  41 #define I2C_MRXADDR_HIGH        (1 << 26)
  42
  43 /* the slave register address accessed  for master rx mode */
  44 #define I2C_MRXRADDR            0x00c
  45 #define I2C_MRXRADDR_LOW        (1 << 24)
  46 #define I2C_MRXRADDR_MID        (1 << 25)
  47 #define I2C_MRXRADDR_HIGH       (1 << 26)
  48
  49 /* master tx count */
  50 #define I2C_MTXCNT              0x010
  51
  52 /* master rx count */
  53 #define I2C_MRXCNT              0x014
  54
  55 /* interrupt enable register */
  56 #define I2C_IEN                 0x018
  57 #define I2C_BTFIEN              (1 << 0)
  58 #define I2C_BRFIEN              (1 << 1)
  59 #define I2C_MBTFIEN             (1 << 2)
  60 #define I2C_MBRFIEN             (1 << 3)
  61 #define I2C_STARTIEN            (1 << 4)
  62 #define I2C_STOPIEN             (1 << 5)
  63 #define I2C_NAKRCVIEN           (1 << 6)
  64 #define IRQ_MST_ENABLE          (I2C_MBTFIEN | I2C_MBRFIEN | I2C_NAKRCVIEN | I2C_STARTIEN | I2C_STOPIEN)
  65 #define IRQ_ALL_DISABLE         0
  66
  67 /* interrupt pending register */
  68 #define I2C_IPD                 0x01c
  69 #define I2C_BTFIPD              (1 << 0)
  70 #define I2C_BRFIPD              (1 << 1)
  71 #define I2C_MBTFIPD             (1 << 2)
  72 #define I2C_MBRFIPD             (1 << 3)
  73 #define I2C_STARTIPD            (1 << 4)
  74 #define I2C_STOPIPD             (1 << 5)
  75 #define I2C_NAKRCVIPD           (1 << 6)
  76 #define I2C_IPD_ALL_CLEAN       0x7f
  77
  78 /* finished count */
  79 #define I2C_FCNT                0x020
  80
  81 /* I2C tx data register */
  82 #define I2C_TXDATA_BASE         0X100
  83
  84 /* I2C rx data register */
  85 #define I2C_RXDATA_BASE         0x200
  86
  87
  88 static void rk30_show_regs(struct rk30_i2c *i2c)
  89 {
  90         int i;
  91         i2c_dbg(i2c->dev, "i2c->start = %d\n", i2c->state);
  92         i2c_dbg(i2c->dev, "I2C_CON: 0x%08x\n", i2c_readl(i2c->regs + I2C_CON));
  93         i2c_dbg(i2c->dev, "I2C_CLKDIV: 0x%08x\n", i2c_readl(i2c->regs + I2C_CLKDIV));
  94         i2c_dbg(i2c->dev, "I2C_MRXADDR: 0x%08x\n", i2c_readl(i2c->regs + I2C_MRXADDR));
  95         i2c_dbg(i2c->dev, "I2C_MRXRADDR: 0x%08x\n", i2c_readl(i2c->regs + I2C_MRXRADDR));
  96         i2c_dbg(i2c->dev, "I2C_MTXCNT: 0x%08x\n", i2c_readl(i2c->regs + I2C_MTXCNT));
  97         i2c_dbg(i2c->dev, "I2C_MRXCNT: 0x%08x\n", i2c_readl(i2c->regs + I2C_MRXCNT));
  98         i2c_dbg(i2c->dev, "I2C_IEN: 0x%08x\n", i2c_readl(i2c->regs + I2C_IEN));
  99         i2c_dbg(i2c->dev, "I2C_IPD: 0x%08x\n", i2c_readl(i2c->regs + I2C_IPD));
 100         i2c_dbg(i2c->dev, "I2C_FCNT: 0x%08x\n", i2c_readl(i2c->regs + I2C_FCNT));
 101         for( i = 0; i < 8; i ++)
 102                 i2c_dbg(i2c->dev, "I2C_TXDATA%d: 0x%08x\n", i, i2c_readl(i2c->regs + I2C_TXDATA_BASE + i * 4));
 103         for( i = 0; i < 8; i ++)
 104                 i2c_dbg(i2c->dev, "I2C_RXDATA%d: 0x%08x\n", i, i2c_readl(i2c->regs + I2C_RXDATA_BASE + i * 4));
 105 }
 106 static inline void rk30_i2c_enable(struct rk30_i2c *i2c, unsigned int lastnak)
 107 {
 108         unsigned int con = 0;
 109
 110         con |= I2C_CON_EN;
 111         con |= I2C_CON_MOD(i2c->mode);
 112         if(lastnak)
 113                 con |= I2C_CON_LASTACK;
 114         con |= I2C_CON_START;
 115         i2c_writel(con, i2c->regs + I2C_CON);
 116 }
 117 static inline void rk30_i2c_disable(struct rk30_i2c *i2c)
 118 {
 119         i2c_writel( 0, i2c->regs + I2C_CON);
 120 }
 121
 122 static inline void rk30_i2c_clean_start(struct rk30_i2c *i2c)
 123 {
 124         unsigned int con = i2c_readl(i2c->regs + I2C_CON);
 125
 126         con &= ~I2C_CON_START;
 127         i2c_writel(con, i2c->regs + I2C_CON);
 128 }
 129 static inline void rk30_i2c_send_start(struct rk30_i2c *i2c)
 130 {
 131         unsigned int con = i2c_readl(i2c->regs + I2C_CON);
 132
 133         con |= I2C_CON_START;
 134         if(con & I2C_CON_STOP)
 135                 dev_warn(i2c->dev, "I2C_CON: stop bit is set\n");
 136
 137         i2c_writel(con, i2c->regs + I2C_CON);
 138 }
 139 static inline void rk30_i2c_send_stop(struct rk30_i2c *i2c)
 140 {
 141         unsigned int con = i2c_readl(i2c->regs + I2C_CON);
 142
 143         con |= I2C_CON_STOP;
 144         if(con & I2C_CON_START)
 145                 dev_warn(i2c->dev, "I2C_CON: start bit is set\n");
 146
 147         i2c_writel(con, i2c->regs + I2C_CON);
 148 }
 149 static inline void rk30_i2c_clean_stop(struct rk30_i2c *i2c)
 150 {
 151         unsigned int con = i2c_readl(i2c->regs + I2C_CON);
 152
 153         con &= ~I2C_CON_STOP;
 154         i2c_writel(con, i2c->regs + I2C_CON);
 155 }
 156
 157 static inline void rk30_i2c_disable_irq(struct rk30_i2c *i2c)
 158 {
 159         i2c_writel(IRQ_ALL_DISABLE, i2c->regs + I2C_IEN);
 160 }
 161
 162 static inline void rk30_i2c_enable_irq(struct rk30_i2c *i2c)
 163 {
 164         i2c_writel(IRQ_MST_ENABLE, i2c->regs + I2C_IEN);
 165 }
 166
 167 /* SCL Divisor = 8 * (CLKDIVL + CLKDIVH)
 168  * SCL = i2c_rate/ SCLK Divisor
 169 */
 170 static void  rk30_i2c_set_clk(struct rk30_i2c *i2c, unsigned long scl_rate)
 171 {
 172         unsigned long i2c_rate = clk_get_rate(i2c->clk);
 173
 174         unsigned int div, divl, divh;
 175
 176         if((scl_rate == i2c->scl_rate) && (i2c_rate == i2c->i2c_rate))
 177                 return;
 178         i2c->i2c_rate = i2c_rate;
 179         i2c->scl_rate = scl_rate;
 180         div = rk30_ceil(i2c_rate, scl_rate * 8);
 181         divh = divl = rk30_ceil(div, 2);
 182         i2c_writel(I2C_CLKDIV_VAL(divl, divh), i2c->regs + I2C_CLKDIV);
 183         i2c_dbg(i2c->dev, "set clk(I2C_CLKDIV: 0x%08x)\n", i2c_readl(i2c->regs + I2C_CLKDIV));
 184         return;
 185 }
 186 static void rk30_i2c_init_hw(struct rk30_i2c *i2c, unsigned long scl_rate)
 187 {
 188         i2c->scl_rate = 0;
 189         rk30_i2c_set_clk(i2c, scl_rate);
 190         return;
 191 }
 192 /* returns TRUE if we this is the last byte in the current message */
 193 static inline int is_msglast(struct rk30_i2c *i2c)
 194 {
 195         return i2c->msg_ptr == i2c->msg->len-1;
 196 }
 197
 198 /* returns TRUE if we reached the end of the current message */
 199 static inline int is_msgend(struct rk30_i2c *i2c)
 200 {
 201         return i2c->msg_ptr >= i2c->msg->len;
 202 }
 203
 204 static void rk30_i2c_stop(struct rk30_i2c *i2c, int ret)
 205 {
 206
 207         i2c->msg_ptr = 0;
 208         i2c->msg = NULL;
 209         if(ret == -EAGAIN){
 210                 i2c->state = STATE_IDLE;
 211                 i2c->is_busy = 0;
 212                 wake_up(&i2c->wait);
 213                 return;
 214         }
 215         i2c->error = ret;
 216         i2c_writel(I2C_STOPIEN, i2c->regs + I2C_IEN);
 217         i2c->state = STATE_STOP;
 218         rk30_i2c_send_stop(i2c);
 219         return;
 220 }
 221 static inline void rk30_set_rx_mode(struct rk30_i2c *i2c, unsigned int lastnak)
 222 {
 223         unsigned long con = i2c_readl(i2c->regs + I2C_CON);
 224
 225         con &= (~I2C_CON_MASK);
 226         con |= (I2C_CON_MOD_RX << 1);
 227         if(lastnak)
 228                 con |= I2C_CON_LASTACK;
 229         i2c_writel(con, i2c->regs + I2C_CON);
 230 }
 231 static void rk30_irq_read_prepare(struct rk30_i2c *i2c)
 232 {
 233     unsigned int cnt, len = i2c->msg->len - i2c->msg_ptr;
 234
 235     if(len <= 32 && i2c->msg_ptr != 0)
 236             rk30_set_rx_mode(i2c, 1);
 237     else if(i2c->msg_ptr != 0)
 238             rk30_set_rx_mode(i2c, 0);
 239
 240     if(is_msgend(i2c)) {
 241         rk30_i2c_stop(i2c, i2c->error);
 242         return;
 243     }
 244     if(len > 32)
 245         cnt = 32;
 246     else
 247         cnt = len;
 248     i2c_writel(cnt, i2c->regs + I2C_MRXCNT);
 249 }
 250 static void rk30_irq_read_get_data(struct rk30_i2c *i2c)
 251 {
 252      unsigned int i, len = i2c->msg->len - i2c->msg_ptr;
 253      unsigned int p;
 254
 255      len = (len >= 32)?32:len;
 256
 257      for(i = 0; i < len; i++){
 258          if(i%4 == 0)
 259              p = i2c_readl(i2c->regs + I2C_RXDATA_BASE +  (i/4) * 4);
 260          i2c->msg->buf[i2c->msg_ptr++] = (p >>((i%4) * 8)) & 0xff;
 261     }
 262
 263      return;
 264 }
 265 static void rk30_irq_write_prepare(struct rk30_i2c *i2c)
 266 {
 267     unsigned int data = 0, cnt = 0, i, j;
 268     unsigned char byte;
 269
 270     if(is_msgend(i2c)) {
 271         rk30_i2c_stop(i2c, i2c->error);
 272         return;
 273     }
 274     for(i = 0; i < 8; i++){
 275         data = 0;
 276         for(j = 0; j < 4; j++) {
 277             if(is_msgend(i2c))
 278                 break;
 279             if(i2c->msg_ptr == 0 && cnt == 0)
 280                 byte = (i2c->addr & 0x7f) << 1;
 281             else
 282                 byte =  i2c->msg->buf[i2c->msg_ptr++];
 283             cnt++;
 284             data |= (byte << (j * 8));
 285         }
 286         i2c_writel(data, i2c->regs + I2C_TXDATA_BASE + 4 * i);
 287         if(is_msgend(i2c))
 288             break;
 289     }
 290     i2c_writel(cnt, i2c->regs + I2C_MTXCNT);
 291 }
 292 static void rk30_i2c_irq_nextblock(struct rk30_i2c *i2c, unsigned int ipd)
 293 {
 294         switch (i2c->state) {
 295         case STATE_START:
 296                 if(!(ipd & I2C_STARTIPD)){
 297                         rk30_i2c_stop(i2c, -ENXIO);
 298                         dev_err(i2c->dev, "Addr[0x%02x] no start irq in STATE_START\n", i2c->addr);
 299                         rk30_show_regs(i2c);
 300                         i2c_writel(I2C_IPD_ALL_CLEAN, i2c->regs + I2C_IPD);
 301                         goto out;
 302                 }
 303                 i2c->complete_what |= 1<<i2c->state;
 304                 i2c_writel(I2C_STARTIPD, i2c->regs + I2C_IPD);
 305                 rk30_i2c_clean_start(i2c);
 306                 if(i2c->mode ==  I2C_CON_MOD_TX){
 307                         i2c_writel(I2C_MBTFIEN  | I2C_NAKRCVIEN, i2c->regs + I2C_IEN);
 308                         i2c->state = STATE_WRITE;
 309                         goto prepare_write;
 310                 } else {
 311                         i2c_writel(I2C_MBRFIEN | I2C_NAKRCVIEN, i2c->regs + I2C_IEN);
 312                         i2c->state = STATE_READ;
 313                         goto prepare_read;
 314                 }
 315         case STATE_WRITE:
 316                 if(!(ipd & I2C_MBTFIPD)){
 317                         rk30_i2c_stop(i2c, -ENXIO);
 318                         dev_err(i2c->dev, "Addr[0x%02x] no mbtf irq in STATE_WRITE\n", i2c->addr);
 319                         rk30_show_regs(i2c);
 320                         i2c_writel(I2C_IPD_ALL_CLEAN, i2c->regs + I2C_IPD);
 321                         goto out;
 322                 }
 323                 i2c->complete_what |= 1<<i2c->state;
 324                 i2c_writel(I2C_MBTFIPD, i2c->regs + I2C_IPD);
 325 prepare_write:
 326                 rk30_irq_write_prepare(i2c);
 327                 break;
 328         case STATE_READ:
 329                 if(!(ipd & I2C_MBRFIPD)){
 330                         rk30_i2c_stop(i2c, -ENXIO);
 331                         dev_err(i2c->dev, "Addr[0x%02x] no mbrf irq in STATE_READ, ipd = 0x%x\n", i2c->addr, ipd);
 332                         rk30_show_regs(i2c);
 333                         i2c_writel(I2C_IPD_ALL_CLEAN, i2c->regs + I2C_IPD);
 334                         goto out;
 335                 }
 336                 i2c->complete_what |= 1<<i2c->state;
 337                 i2c_writel(I2C_MBRFIPD, i2c->regs + I2C_IPD);
 338                 rk30_irq_read_get_data(i2c);
 339 prepare_read:
 340                 rk30_irq_read_prepare(i2c);
 341                 break;
 342         case STATE_STOP:
 343                 if(!(ipd & I2C_STOPIPD)){
 344                         rk30_i2c_stop(i2c, -ENXIO);
 345                         dev_err(i2c->dev, "Addr[0x%02x] no stop irq in STATE_STOP\n", i2c->addr);
 346                         rk30_show_regs(i2c);
 347                         i2c_writel(I2C_IPD_ALL_CLEAN, i2c->regs + I2C_IPD);
 348                         goto out;
 349                 }
 350                 rk30_i2c_clean_stop(i2c);
 351                 i2c_writel(I2C_STOPIPD, i2c->regs + I2C_IPD);
 352                 i2c->state = STATE_IDLE;
 353                 i2c->is_busy = 0;
 354                 i2c->complete_what |= 1<<i2c->state;
 355                 wake_up(&i2c->wait);
 356                 break;
 357         default:
 358                 break;
 359         }
 360 out:
 361         return;
 362 }
 363 static irqreturn_t rk30_i2c_irq(int irq, void *dev_id)
 364 {
 365         struct rk30_i2c *i2c = dev_id;
 366         unsigned int ipd;
 367
 368         spin_lock(&i2c->lock);
 369         ipd = i2c_readl(i2c->regs + I2C_IPD);
 370         if(i2c->state == STATE_IDLE){
 371                 dev_info(i2c->dev, "Addr[0x%02x]  irq in STATE_IDLE, ipd = 0x%x\n", i2c->addr, ipd);
 372                 i2c_writel(I2C_IPD_ALL_CLEAN, i2c->regs + I2C_IPD);
 373                 goto out;
 374         }
 375
 376         if(ipd & I2C_NAKRCVIPD){
 377                 i2c_writel(I2C_NAKRCVIPD, i2c->regs + I2C_IPD);
 378                 i2c->error = -EAGAIN;
 379                 goto out;
 380         }
 381         rk30_i2c_irq_nextblock(i2c, ipd);
 382 out:
 383         spin_unlock(&i2c->lock);
 384         return IRQ_HANDLED;
 385 }
 386
 387
 388 static int rk30_i2c_set_master(struct rk30_i2c *i2c, struct i2c_msg *msgs, int num)
 389 {
 390         unsigned int addr = (msgs[0].addr & 0x7f) << 1;
 391         unsigned int reg_valid_bits = 0;
 392         unsigned int reg_addr = 0;
 393
 394         if(num == 1) {
 395                 i2c->count = msgs[0].len;
 396                 if(!(msgs[0].flags & I2C_M_RD)){
 397                         i2c->msg = &msgs[0];
 398                         i2c->mode = I2C_CON_MOD_TX;
 399                 }
 400                 else {
 401                         addr |= 1;
 402                         i2c->msg = &msgs[0];
 403                         i2c_writel(addr | I2C_MRXADDR_LOW, i2c->regs + I2C_MRXADDR);
 404                         i2c_writel(0, i2c->regs + I2C_MRXRADDR);
 405                         i2c->mode = I2C_CON_MOD_TRX;
 406                         //i2c->mode = I2C_CON_MOD_RX;
 407                 }
 408         }
 409         else if(num == 2) {
 410                 i2c->count = msgs[1].len;
 411                 switch(msgs[0].len){
 412                 case 1:
 413                         reg_addr = msgs[0].buf[0];
 414                         reg_valid_bits |= I2C_MRXADDR_LOW;
 415                         break;
 416                 case 2:
 417                         reg_addr = msgs[0].buf[0] | (msgs[0].buf[1] << 8);
 418                         reg_valid_bits |= I2C_MRXADDR_LOW | I2C_MRXADDR_MID;
 419                         break;
 420                 case 3:
 421                         reg_addr = msgs[0].buf[0] | (msgs[0].buf[1] << 8) | (msgs[0].buf[2] << 16);
 422                         reg_valid_bits |= I2C_MRXADDR_LOW | I2C_MRXADDR_MID | I2C_MRXADDR_HIGH;
 423                         break;
 424                 default:
 425                         return -EIO;
 426                 }
 427                 if((msgs[0].flags & I2C_M_RD) && (msgs[1].flags & I2C_M_RD)) {
 428                         addr |= 1;
 429                         i2c->msg = &msgs[1];
 430                         i2c_writel(addr | I2C_MRXADDR_LOW, i2c->regs + I2C_MRXADDR);
 431                         i2c_writel(reg_addr | reg_valid_bits, i2c->regs + I2C_MRXRADDR);
 432                         i2c->mode = I2C_CON_MOD_RRX;
 433                 }
 434                 else if(!(msgs[0].flags & I2C_M_RD) && (msgs[1].flags & I2C_M_RD)) {
 435                         i2c->msg = &msgs[1];
 436                         i2c_writel(addr | I2C_MRXADDR_LOW, i2c->regs + I2C_MRXADDR);
 437                         i2c_writel(reg_addr | reg_valid_bits, i2c->regs + I2C_MRXRADDR);
 438                         i2c->mode = I2C_CON_MOD_TRX;
 439                 }
 440                 else
 441                         return -EIO;
 442         }
 443         else {
 444                 dev_err(i2c->dev, "This case(num > 2) has not been support now\n");
 445                 return -EIO;
 446         }
 447
 448         return 0;
 449 }
 450 /* rk30_i2c_doxfer
 451  *
 452  * this starts an i2c transfer
 453 */
 454 static int rk30_i2c_doxfer(struct rk30_i2c *i2c,
 455                               struct i2c_msg *msgs, int num)
 456 {
 457         unsigned long timeout, flags;
 458
 459         if (i2c->suspended)
 460                 return -EIO;
 461
 462         spin_lock_irqsave(&i2c->lock, flags);
 463         if(rk30_i2c_set_master(i2c, msgs, num) < 0){
 464                 spin_unlock_irqrestore(&i2c->lock, flags);
 465                 dev_err(i2c->dev, "addr[0x%02x] set master error\n", msgs[0].addr);
 466                 return -EIO;
 467         }
 468         i2c->addr = msgs[0].addr;
 469         i2c->msg_ptr = 0;
 470         i2c->error = 0;
 471         i2c->is_busy = 1;
 472         i2c->state = STATE_START;
 473         i2c->complete_what = 0;
 474         i2c_writel(I2C_STARTIEN, i2c->regs + I2C_IEN);
 475         spin_unlock_irqrestore(&i2c->lock, flags);
 476
 477         rk30_i2c_enable(i2c, (i2c->count > 32)?0:1); //if count > 32,  byte(32) send ack
 478
 479         timeout = wait_event_timeout(i2c->wait, (i2c->is_busy == 0), msecs_to_jiffies(I2C_WAIT_TIMEOUT));
 480
 481         spin_lock_irqsave(&i2c->lock, flags);
 482         i2c_writel(I2C_IPD_ALL_CLEAN, i2c->regs + I2C_IPD);
 483         spin_unlock_irqrestore(&i2c->lock, flags);
 484
 485         if (timeout == 0){
 486                 dev_err(i2c->dev, "addr[0x%02x] wait event timeout, state: %d, is_busy: %d, error: %d, complete_what: 0x%x\n",
 487                                 msgs[0].addr, i2c->state, i2c->is_busy, i2c->error, i2c->complete_what);
 488                 i2c->state = STATE_IDLE;
 489                 if((i2c->error < 0) || (i2c->is_busy != 0) || !(i2c->complete_what & (1 << STATE_STOP)))
 490                         i2c->error = -ETIMEDOUT;
 491                 rk30_i2c_send_stop(i2c);
 492
 493         }
 494         rk30_i2c_disable_irq(i2c);
 495         rk30_i2c_disable(i2c);
 496
 497         if(i2c->error == -EAGAIN)
 498                 dev_err(i2c->dev, "No ack(retry: %d, complete_what: 0x%x), Maybe slave(addr: 0x%02x) not exist or abnormal power-on\n",
 499                                 i2c->adap.retries + 1, i2c->complete_what, i2c->addr);
 500         return i2c->error;
 501 }
 502
 503 /* rk30_i2c_xfer
 504  *
 505  * first port of call from the i2c bus code when an message needs
 506  * transferring across the i2c bus.
 507 */
 508
 509 static int rk30_i2c_xfer(struct i2c_adapter *adap,
 510                         struct i2c_msg *msgs, int num)
 511 {
 512         int ret = 0;
 513         unsigned long scl_rate;
 514         struct rk30_i2c *i2c = (struct rk30_i2c *)adap->algo_data;
 515
 516         clk_enable(i2c->clk);
 517
 518         if(msgs[0].scl_rate <= 400000 && msgs[0].scl_rate >= 10000)
 519                 scl_rate = msgs[0].scl_rate;
 520         else if(msgs[0].scl_rate > 400000){
 521                 dev_warn(i2c->dev, "Warning: addr[0x%x] msg[0].scl_rate( = %dKhz) is too high!",
 522                         msgs[0].addr, msgs[0].scl_rate/1000);
 523                 scl_rate = 400000;
 524         }
 525         else{
 526                 dev_warn(i2c->dev, "Warning: addr[0x%x] msg[0].scl_rate( = %dKhz) is too low!",
 527                         msgs[0].addr, msgs[0].scl_rate/1000);
 528                 scl_rate = 10000;
 529         }
 530         if(i2c->is_div_from_arm[i2c->adap.nr]){
 531                 mutex_lock(&i2c->m_lock);
 532                 wake_lock(&i2c->idlelock[i2c->adap.nr]);
 533         }
 534
 535         rk30_i2c_set_clk(i2c, scl_rate);
 536         i2c_dbg(i2c->dev, "i2c transfer start: addr: 0x%x, scl_reate: %ldKhz, len: %d\n", msgs[0].addr, scl_rate/1000, num);
 537         ret = rk30_i2c_doxfer(i2c, msgs, num);
 538         i2c_dbg(i2c->dev, "i2c transfer stop: addr: 0x%x, state: %d, ret: %d\n", msgs[0].addr, ret, i2c->state);
 539
 540         if(i2c->is_div_from_arm[i2c->adap.nr]){
 541                 wake_unlock(&i2c->idlelock[i2c->adap.nr]);
 542                 mutex_unlock(&i2c->m_lock);
 543         }
 544
 545         clk_disable(i2c->clk);
 546         return (ret < 0)?ret:num;
 547 }
 548
 549 /* declare our i2c functionality */
 550 static u32 rk30_i2c_func(struct i2c_adapter *adap)
 551 {
 552         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_PROTOCOL_MANGLING;
 553 }
 554
 555 /* i2c bus registration info */
 556
 557 static const struct i2c_algorithm rk30_i2c_algorithm = {
 558         .master_xfer            = rk30_i2c_xfer,
 559         .functionality          = rk30_i2c_func,
 560 };
 561
 562 int i2c_add_rk30_adapter(struct i2c_adapter *adap)
 563 {
 564         int ret = 0;
 565         struct rk30_i2c *i2c = (struct rk30_i2c *)adap->algo_data;
 566
 567         adap->algo = &rk30_i2c_algorithm;
 568
 569         i2c->i2c_init_hw = &rk30_i2c_init_hw;
 570         i2c->i2c_set_clk = &rk30_i2c_set_clk;
 571         i2c->i2c_irq = &rk30_i2c_irq;
 572
 573         ret = i2c_add_numbered_adapter(adap);
 574
 575         return ret;
 576 }
 577