drivers/i2c/busses/i2c-rk29.c

   1 /* drivers/i2c/busses/i2c_rk29.c
   2  *
   3  * Copyright (C) 2010 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 <linux/kernel.h>
  16 #include <linux/delay.h>
  17 #include <linux/module.h>
  18 #include <linux/completion.h>
  19 #include <linux/init.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/spinlock.h>
  22 #include <linux/err.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/cpufreq.h>
  25 #include <linux/device.h>
  26 #include <linux/clk.h>
  27 #include <linux/delay.h>
  28 #include <linux/i2c.h>
  29 #include <linux/wakelock.h>
  30 #include <linux/slab.h>
  31 #include <mach/board.h>
  32 #include <asm/io.h>
  33
  34 #include "i2c-rk29.h"
  35 #define DRV_NAME        "rk29_i2c"
  36 #define RETRY_NUM       1
  37
  38 #define RK29_UDELAY_TIME(scl_rate)                      ((400*1000)/(scl_rate))
  39 /*max ACK delay time = RK29_I2C_ACK_TIMEOUT_COUNT * RK29_UDELAY_TIME(scl_rate)   us */
  40 #define RK29_I2C_ACK_TIMEOUT_COUNT                      (100 * 1000)
  41 /*max STOP delay time = RK29_I2C_STOP_TIMEOUT_COUNT * RK29_UDELAY_TIME(scl_rate)   us */
  42 #define RK29_I2C_STOP_TIMEOUT_COUNT                     70//1000
  43 /*max START delay time = RK29_I2C_START_TIMEOUT_COUNT * RK29_UDELAY_TIME(scl_rate)   us */
  44 #define RK29_I2C_START_TIMEOUT_COUNT            1000
  45
  46
  47
  48 #if 0
  49 #define i2c_dbg(dev, format, arg...)            \
  50         dev_printk(KERN_INFO , dev , format , ## arg)
  51 #define i2c_err(dev, format, arg...)            \
  52                 dev_printk(KERN_ERR , dev , format , ## arg)
  53
  54 #else
  55 #define i2c_dbg(dev, format, arg...)
  56 #define i2c_err(dev, format, arg...)
  57
  58 #endif
  59
  60 enum rk29_error {
  61         RK29_ERROR_NONE = 0,
  62         RK29_ERROR_ARBITR_LOSE,
  63         RK29_ERROR_UNKNOWN
  64 };
  65
  66 enum rk29_event {
  67         RK29_EVENT_NONE = 0,
  68         /* master has received ack(MTX mode)
  69            means that data has been sent to slave.
  70          */
  71         RK29_EVENT_MTX_RCVD_ACK,
  72         /* master needs to send ack to slave(MRX mode)
  73            means that data has been received from slave.
  74          */
  75         RK29_EVENT_MRX_NEED_ACK,
  76         RK29_EVENT_MAX
  77 };
  78
  79 struct rk29_i2c_data {
  80         struct device                   *dev;
  81         struct i2c_adapter              adap;
  82         void __iomem                    *regs;
  83         struct resource                 *ioarea;
  84
  85         unsigned int                    ack_timeout;    //unit: us
  86         unsigned int                    udelay_time;    //unit: us
  87
  88         unsigned int                    suspended:1;
  89         unsigned long                   scl_rate;
  90         unsigned long                   i2c_rate;
  91         struct clk                              *clk;
  92
  93         unsigned int                    mode;
  94         int                                     retry;
  95
  96         int                                     poll_status;
  97
  98         unsigned int                    irq;
  99
 100         spinlock_t                              cmd_lock;
 101         struct completion               cmd_complete;
 102         enum rk29_event         cmd_event;
 103         enum rk29_error         cmd_err;
 104
 105         unsigned int                    msg_idx;
 106         unsigned int                    msg_num;
 107         int                                             udelay;
 108         int (*io_init)(void);
 109 #ifdef CONFIG_CPU_FREQ
 110                 struct notifier_block   freq_transition;
 111 #endif
 112 };
 113
 114 #if defined(CONFIG_ARCH_RK29) || defined(CONFIG_ARCH_RK30)
 115 static struct wake_lock idlelock; /* only for i2c0 */
 116 #endif
 117
 118 static void rk29_set_ack(struct rk29_i2c_data *i2c)
 119 {
 120         unsigned long conr = readl(i2c->regs + I2C_CONR);
 121
 122         conr &= I2C_CONR_ACK;
 123         writel(conr,i2c->regs + I2C_CONR);
 124         return;
 125 }
 126 static void rk29_set_nak(struct rk29_i2c_data *i2c)
 127 {
 128         unsigned long conr = readl(i2c->regs + I2C_CONR);
 129
 130         conr |= I2C_CONR_NAK;
 131         writel(conr,i2c->regs + I2C_CONR);
 132         return;
 133 }
 134
 135
 136 static inline void rk29_i2c_disable_irqs(struct rk29_i2c_data *i2c)
 137 {
 138         unsigned long tmp;
 139
 140         tmp = readl(i2c->regs + I2C_IER);
 141         writel(tmp & IRQ_ALL_DISABLE, i2c->regs + I2C_IER);
 142 }
 143 static inline void rk29_i2c_enable_irqs(struct rk29_i2c_data *i2c)
 144 {
 145         unsigned long tmp;
 146
 147         tmp = readl(i2c->regs + I2C_IER);
 148         writel(tmp | IRQ_MST_ENABLE, i2c->regs + I2C_IER);
 149 }
 150
 151 /* scl = pclk/(5 *(rem+1) * 2^(exp+1)) */
 152 static void rk29_i2c_calcdivisor(unsigned long pclk,
 153                                                                 unsigned long scl_rate,
 154                                                                 unsigned long *real_rate,
 155                                                                 unsigned int *rem, unsigned int *exp)
 156 {
 157         unsigned int calc_rem = 0;
 158         unsigned int calc_exp = 0;
 159
 160         for(calc_exp = 0; calc_exp < I2CCDVR_EXP_MAX; calc_exp++)
 161         {
 162                 calc_rem = pclk / (5 * scl_rate * (1 <<(calc_exp +1)));
 163                 if(calc_rem < I2CCDVR_REM_MAX)
 164                         break;
 165         }
 166         if(calc_rem >= I2CCDVR_REM_MAX || calc_exp >= I2CCDVR_EXP_MAX)
 167         {
 168                 calc_rem = I2CCDVR_REM_MAX - 1;
 169                 calc_exp = I2CCDVR_EXP_MAX - 1;
 170         }
 171         *rem = calc_rem;
 172         *exp = calc_exp;
 173         *real_rate = pclk/(5 * (calc_rem + 1) * (1 <<(calc_exp +1)));
 174         return;
 175 }
 176 /* set i2c bus scl rate */
 177 static void  rk29_i2c_clockrate(struct rk29_i2c_data *i2c)
 178 {
 179
 180         struct rk29_i2c_platform_data *pdata = i2c->dev->platform_data;
 181         unsigned int rem = 0, exp = 0;
 182         unsigned long scl_rate, real_rate = 0, tmp;
 183
 184         i2c->i2c_rate = clk_get_rate(i2c->clk);
 185
 186         scl_rate = (i2c->scl_rate) ? i2c->scl_rate : ((pdata->scl_rate)? pdata->scl_rate:100000);
 187
 188         rk29_i2c_calcdivisor(i2c->i2c_rate, scl_rate, &real_rate, &rem, &exp);
 189
 190         tmp = readl(i2c->regs + I2C_OPR);
 191         tmp &= ~0x3f;
 192         tmp |= exp;
 193         tmp |= rem<<I2CCDVR_EXP_BITS;
 194         writel(tmp, i2c->regs + I2C_OPR);
 195         if(real_rate > 400000)
 196                 dev_warn(i2c->dev, "i2c_rate[%luKhz], scl_rate[%luKhz], real_rate[%luKhz] > 400Khz\n",
 197                                 i2c->i2c_rate/1000, scl_rate/1000, real_rate/1000);
 198         else
 199                 i2c_dbg(i2c->dev, "i2c_rate[%luKhz], scl_rate[%luKhz], real_rate[%luKhz]\n",
 200                                 i2c->i2c_rate/1000, scl_rate/1000, real_rate/1000);
 201         return;
 202 }
 203 static int rk29_event_occurred(struct rk29_i2c_data *i2c)
 204 {
 205         unsigned long isr, lsr;
 206
 207         isr = readl(i2c->regs + I2C_ISR);
 208         lsr = readl(i2c->regs + I2C_LSR);
 209         i2c_dbg(i2c->dev,"event occurred, isr = %lx, lsr = %lx\n", isr, lsr);
 210         if(isr & I2C_ISR_ARBITR_LOSE)
 211         {
 212                 writel(0, i2c->regs + I2C_ISR);
 213                 i2c->cmd_err = RK29_ERROR_ARBITR_LOSE;
 214                 i2c_err(i2c->dev, "<error>arbitration loss\n");
 215                 return 0;
 216         }
 217
 218         switch(i2c->cmd_event)
 219         {
 220                 case RK29_EVENT_MTX_RCVD_ACK:
 221                         if(isr & I2C_ISR_MTX_RCVD_ACK)
 222                         {
 223                                 isr &= ~I2C_ISR_MTX_RCVD_ACK;
 224                                 writel(isr, i2c->regs + I2C_ISR);
 225                                 return 1;
 226                         }
 227                 break;
 228                 case RK29_EVENT_MRX_NEED_ACK:
 229                         if(isr & I2C_ISR_MRX_NEED_ACK)
 230                         {
 231                                 isr &= ~I2C_ISR_MRX_NEED_ACK;
 232                                 writel(isr, i2c->regs + I2C_ISR);
 233                                 return 1;
 234                         }
 235                         break;
 236                 default:
 237                         break;
 238         }
 239         writel(0, i2c->regs + I2C_ISR);
 240         i2c->cmd_err = RK29_ERROR_UNKNOWN;
 241         return 0;
 242 }
 243
 244 static irqreturn_t rk29_i2c_irq(int irq, void *data)
 245 {
 246         struct rk29_i2c_data *i2c = (struct rk29_i2c_data *)data;
 247         int res;
 248
 249         rk29_i2c_disable_irqs(i2c);
 250         spin_lock(&i2c->cmd_lock);
 251         res = rk29_event_occurred(i2c);
 252         if(res)
 253         {
 254                 if(i2c->mode == I2C_MODE_IRQ)
 255                         complete(&i2c->cmd_complete);
 256                 else
 257                         i2c->poll_status = 1;
 258         }
 259         spin_unlock(&i2c->cmd_lock);
 260         return IRQ_HANDLED;
 261 }
 262 static int wait_for_completion_poll_timeout(struct rk29_i2c_data *i2c)
 263 {
 264         int tmo = RK29_I2C_ACK_TIMEOUT_COUNT;
 265
 266         while(--tmo)
 267         {
 268                 if(i2c->poll_status == 1)
 269                         return 1;
 270                 udelay(i2c->udelay_time);
 271         }
 272         return 0;
 273 }
 274 static int rk29_wait_event(struct rk29_i2c_data *i2c,
 275                                         enum rk29_event mr_event)
 276 {
 277         int ret = 0;
 278
 279         if(unlikely(irqs_disabled()))
 280         {
 281                 i2c_err(i2c->dev, "irqs are disabled on this system!\n");
 282                 return -EIO;
 283         }
 284         i2c->cmd_err = RK29_ERROR_NONE;
 285         i2c->cmd_event = mr_event;
 286         rk29_i2c_enable_irqs(i2c);
 287         if(i2c->mode == I2C_MODE_IRQ)
 288         {
 289                 ret = wait_for_completion_interruptible_timeout(&i2c->cmd_complete,
 290                                                                 usecs_to_jiffies(i2c->ack_timeout));
 291         }
 292         else
 293         {
 294                 i2c->poll_status = 0;
 295                 ret = wait_for_completion_poll_timeout(i2c);
 296         }
 297         if(ret < 0)
 298         {
 299                 i2c_err(i2c->dev, "i2c wait for event %04x, retrun %d \n", mr_event, ret);
 300                 return ret;
 301         }
 302         if(ret == 0)
 303         {
 304                 i2c_err(i2c->dev, "i2c wait for envent timeout, but not return -ETIMEDOUT\n");
 305                 return 0;
 306                 //return -ETIMEDOUT;
 307         }
 308         return 0;
 309 }
 310
 311 static void rk29_i2c_stop(struct rk29_i2c_data *i2c)
 312 {
 313         int tmo = RK29_I2C_STOP_TIMEOUT_COUNT;
 314
 315         writel(I2C_LCMR_STOP|I2C_LCMR_RESUME, i2c->regs + I2C_LCMR);
 316         while(--tmo && !(readl(i2c->regs + I2C_LCMR) & I2C_LCMR_STOP))
 317         {
 318                 udelay(i2c->udelay_time);
 319         }
 320         writel(0, i2c->regs + I2C_ISR);
 321         rk29_i2c_disable_irqs(i2c);
 322
 323         udelay(tmo);
 324         return;
 325 }
 326 static void rk29_wait_while_busy(struct rk29_i2c_data *i2c)
 327 {
 328         int tmo = RK29_I2C_START_TIMEOUT_COUNT;
 329
 330         while(--tmo && (readl(i2c->regs + I2C_LSR) & I2C_LSR_BUSY))
 331         {
 332                 udelay(i2c->udelay_time);
 333         }
 334         return;
 335 }
 336
 337 static int rk29_send_2nd_addr(struct rk29_i2c_data *i2c,
 338                                                 struct i2c_msg *msg, int start)
 339 {
 340         int ret = 0;
 341         unsigned long lsr;
 342         unsigned long addr_2nd = msg->addr & 0xff;
 343
 344         i2c_dbg(i2c->dev, "i2c send addr_2nd: %lx\n", addr_2nd);
 345         writel(addr_2nd, i2c->regs + I2C_MTXR);
 346         if(i2c->mode == I2C_MODE_IRQ)
 347                 INIT_COMPLETION(i2c->cmd_complete);
 348         writel(I2C_LCMR_RESUME, i2c->regs + I2C_LCMR);
 349         rk29_set_ack(i2c);
 350
 351         if((ret = rk29_wait_event(i2c, RK29_EVENT_MTX_RCVD_ACK)) != 0)
 352         {
 353                 i2c_err(i2c->dev, "after sent addr_2nd, i2c wait for ACK timeout\n");
 354                 return ret;
 355         }
 356         lsr = readl(i2c->regs + I2C_LSR);
 357         if((lsr & I2C_LSR_RCV_NAK) && !(msg->flags & I2C_M_IGNORE_NAK))
 358                 return -EINVAL;
 359         return ret;
 360 }
 361 static int rk29_send_address(struct rk29_i2c_data *i2c,
 362                                                 struct i2c_msg *msg, int start)
 363 {
 364         unsigned long addr_1st;
 365         unsigned long conr,lsr;
 366         int ret = 0;
 367
 368         if(msg->flags & I2C_M_TEN)
 369                 addr_1st = (0xf0 | (((unsigned long) msg->addr & 0x300) >> 7)) & 0xff;
 370         else
 371                 addr_1st = ((msg->addr << 1) & 0xff);
 372
 373         if (msg->flags & I2C_M_RD)
 374                 addr_1st |= 0x01;
 375         else
 376                 addr_1st &= (~0x01);
 377
 378         if(start)
 379                 rk29_wait_while_busy(i2c);
 380
 381         writel(0, i2c->regs + I2C_ISR);
 382         conr = readl(i2c->regs + I2C_CONR);
 383         conr |= I2C_CONR_MTX_MODE;
 384         conr |= I2C_CONR_MPORT_ENABLE;
 385         writel(conr, i2c->regs + I2C_CONR);
 386
 387         i2c_dbg(i2c->dev, "i2c send addr_1st: %lx\n", addr_1st);
 388         writel(addr_1st, i2c->regs + I2C_MTXR);
 389         rk29_set_ack(i2c);
 390         if(i2c->mode == I2C_MODE_IRQ)
 391                 INIT_COMPLETION(i2c->cmd_complete);
 392         writel(I2C_LCMR_START|I2C_LCMR_RESUME, i2c->regs + I2C_LCMR);
 393
 394         if((ret = rk29_wait_event(i2c, RK29_EVENT_MTX_RCVD_ACK)) != 0)
 395         {
 396                 i2c_err(i2c->dev, "after sent addr_1st, i2c wait for ACK timeout\n");
 397                 return ret;
 398         }
 399         lsr = readl(i2c->regs + I2C_LSR);
 400         if((lsr & I2C_LSR_RCV_NAK) && !(msg->flags & I2C_M_IGNORE_NAK))
 401         {
 402                 dev_info(i2c->dev, "addr: 0x%x receive no ack\n", msg->addr);
 403                 return -EAGAIN;
 404         }
 405         if(start && (msg->flags & I2C_M_TEN))
 406                 ret = rk29_send_2nd_addr(i2c, msg, start);
 407         return ret;
 408 }
 409
 410 static int rk29_i2c_send_msg(struct rk29_i2c_data *i2c, struct i2c_msg *msg)
 411 {
 412         int i, ret = 0;
 413         unsigned long conr, lsr;
 414
 415         conr = readl(i2c->regs + I2C_CONR);
 416         conr |= I2C_CONR_MTX_MODE;
 417         //conr |= I2C_CONR_MPORT_ENABLE;
 418         writel(conr, i2c->regs + I2C_CONR);
 419
 420         for(i = 0; i < msg->len; i++)
 421         {
 422                 i2c_dbg(i2c->dev, "i2c send buf[%d]: %x\n", i, msg->buf[i]);
 423                 writel(msg->buf[i], i2c->regs + I2C_MTXR);
 424                 rk29_set_ack(i2c);
 425                 if(i2c->mode == I2C_MODE_IRQ)
 426                         INIT_COMPLETION(i2c->cmd_complete);
 427                 writel(I2C_LCMR_RESUME, i2c->regs + I2C_LCMR);
 428
 429                 if((ret = rk29_wait_event(i2c, RK29_EVENT_MTX_RCVD_ACK)) != 0)
 430                         return ret;
 431                 lsr = readl(i2c->regs + I2C_LSR);
 432                 if((lsr & I2C_LSR_RCV_NAK) && (i != msg->len -1) && !(msg->flags & I2C_M_IGNORE_NAK))
 433                         return -EINVAL;
 434                 udelay(i2c->udelay);
 435
 436         }
 437         return ret;
 438 }
 439 static int rk29_i2c_recv_msg(struct rk29_i2c_data *i2c, struct i2c_msg *msg)
 440 {
 441         int i, ret = 0;
 442         unsigned long conr;
 443
 444         conr = readl(i2c->regs + I2C_CONR);
 445         conr &= I2C_CONR_MRX_MODE;
 446         //conr |= I2C_CONR_MPORT_ENABLE;
 447         writel(conr, i2c->regs + I2C_CONR);
 448
 449         for(i = 0; i < msg->len; i++)
 450         {
 451                 if(i2c->mode == I2C_MODE_IRQ)
 452                         INIT_COMPLETION(i2c->cmd_complete);
 453                 writel(I2C_LCMR_RESUME, i2c->regs + I2C_LCMR);
 454                 if((ret = rk29_wait_event(i2c, RK29_EVENT_MRX_NEED_ACK)) != 0)
 455                         return ret;
 456                 msg->buf[i] = (uint8_t)readl(i2c->regs + I2C_MRXR);
 457
 458                 if( i == msg->len -1)
 459                         rk29_set_nak(i2c);
 460                 else
 461                         rk29_set_ack(i2c);
 462                 udelay(i2c->udelay);
 463                 i2c_dbg(i2c->dev, "i2c recv >>>>>>>>>>>> buf[%d]: %x\n", i, msg->buf[i]);
 464         }
 465         return ret;
 466 }
 467 static int rk29_xfer_msg(struct i2c_adapter *adap,
 468                                                  struct i2c_msg *msg, int start, int stop)
 469 {
 470         struct rk29_i2c_data *i2c = (struct rk29_i2c_data *)adap->algo_data;
 471         int ret = 0;
 472
 473         if(msg->len == 0)
 474         {
 475                 ret = -EINVAL;
 476                 i2c_err(i2c->dev, "<error>msg->len = %d\n", msg->len);
 477                 goto exit;
 478         }
 479         if(msg->flags & I2C_M_NEED_DELAY)
 480                 i2c->udelay = msg->udelay;
 481         else
 482                 i2c->udelay = 0;
 483         if((ret = rk29_send_address(i2c, msg, start))!= 0)
 484         {
 485                 rk29_set_nak(i2c);
 486                 i2c_err(i2c->dev, "<error>rk29_send_address timeout\n");
 487                 goto exit;
 488         }
 489         if(msg->flags & I2C_M_RD)
 490         {
 491                 if(msg->flags & I2C_M_REG8_DIRECT)
 492                 {
 493                         struct i2c_msg msg1 = *msg;
 494                         struct i2c_msg msg2 = *msg;
 495                         msg1.len = 1;
 496                         msg2.len = msg->len - 1;
 497                         msg2.buf = msg->buf + 1;
 498
 499                         if((ret = rk29_i2c_send_msg(i2c, &msg1)) != 0)
 500                                 i2c_err(i2c->dev, "<error>rk29_i2c_send_msg timeout\n");
 501                         if((ret = rk29_i2c_recv_msg(i2c, &msg2)) != 0)
 502                         {
 503                                 i2c_err(i2c->dev, "<error>rk29_i2c_recv_msg timeout\n");
 504                                 goto exit;
 505                         }
 506
 507                 }
 508                 else if((ret = rk29_i2c_recv_msg(i2c, msg)) != 0)
 509                 {
 510                         i2c_err(i2c->dev, "<error>rk29_i2c_recv_msg timeout\n");
 511                         goto exit;
 512                 }
 513         }
 514         else
 515         {
 516                 if((ret = rk29_i2c_send_msg(i2c, msg)) != 0)
 517                 {
 518                         rk29_set_nak(i2c);
 519                         i2c_err(i2c->dev, "<error>rk29_i2c_send_msg timeout\n");
 520                         goto exit;
 521                 }
 522         }
 523
 524 exit:
 525         if(stop || ret < 0)
 526         {
 527                 rk29_i2c_stop(i2c);
 528         }
 529         return ret;
 530
 531 }
 532
 533 static int rk29_i2c_xfer(struct i2c_adapter *adap,
 534                         struct i2c_msg *msgs, int num)
 535 {
 536         int ret = -1;
 537         int i;
 538         struct rk29_i2c_data *i2c = (struct rk29_i2c_data *)adap->algo_data;
 539
 540         //int retry = i2c->retry;
 541         /*
 542         if(i2c->suspended ==1)
 543                 return -EIO;
 544         */
 545         // 400k > scl_rate > 10k
 546         if(msgs[0].scl_rate <= 400000 && msgs[0].scl_rate >= 10000)
 547                 i2c->scl_rate = msgs[0].scl_rate;
 548         else if(msgs[0].scl_rate > 400000){
 549                 dev_info(i2c->dev, "Warning: msg[0].scl_rate( = %dKhz) is too high!",
 550                         msgs[0].scl_rate/1000);
 551                 i2c->scl_rate = 400000;
 552         }
 553         else{
 554                 dev_info(i2c->dev, "Warning: msg[0].scl_rate( = %dKhz) is too low!",
 555                         msgs[0].scl_rate/1000);
 556                 i2c->scl_rate = 10000;
 557         }
 558         rk29_i2c_clockrate(i2c);
 559
 560         i2c->udelay_time = RK29_UDELAY_TIME(i2c->scl_rate);
 561         i2c->ack_timeout = RK29_I2C_ACK_TIMEOUT_COUNT * i2c->udelay_time;
 562
 563 #if defined(CONFIG_ARCH_RK29) || defined(CONFIG_ARCH_RK30)
 564         if (adap->nr == 0)
 565                 wake_lock(&idlelock);
 566 #endif
 567
 568         for (i = 0; i < num; i++)
 569         {
 570                 ret = rk29_xfer_msg(adap, &msgs[i], (i == 0), (i == (num - 1)));
 571                 if (ret != 0)
 572                 {
 573                         num = ret;
 574                         i2c_err(i2c->dev, "rk29_xfer_msg error, ret = %d\n", ret);
 575                         break;
 576                 }
 577         }
 578
 579 #if defined(CONFIG_ARCH_RK29) || defined(CONFIG_ARCH_RK30)
 580         if (adap->nr == 0)
 581                 wake_unlock(&idlelock);
 582 #endif
 583
 584         /*
 585         if( --retry && num < 0)
 586         {
 587                 udelay(10000 * 1000/i2c->scl_rate);
 588                 goto retry;
 589         }
 590         */
 591         if(num < 0)
 592                 dev_err(i2c->dev, "i2c transfer err, client address is 0x%x [20110106]\n", msgs[0].addr);
 593         return num;
 594 }
 595
 596 static u32 rk29_i2c_func(struct i2c_adapter *adap)
 597 {
 598         return I2C_FUNC_I2C | I2C_FUNC_10BIT_ADDR;
 599 }
 600
 601 static const struct i2c_algorithm rk29_i2c_algorithm = {
 602         .master_xfer            = rk29_i2c_xfer,
 603         .functionality          = rk29_i2c_func,
 604 };
 605
 606 int i2c_suspended(struct i2c_adapter *adap)
 607 {
 608         struct rk29_i2c_data *i2c = (struct rk29_i2c_data *)adap->algo_data;
 609         if(adap->nr > 1)
 610                 return 1;
 611         if(i2c == NULL)
 612                 return 1;
 613         return i2c->suspended;
 614 }
 615 EXPORT_SYMBOL(i2c_suspended);
 616
 617 static void rk29_i2c_deinit_hw(struct rk29_i2c_data *i2c)
 618 {
 619         unsigned long opr = readl(i2c->regs + I2C_OPR);
 620
 621         opr &= ~I2C_OPR_RESET_STATUS;
 622         writel(opr, i2c->regs);
 623         return;
 624 }
 625 static void rk29_i2c_init_hw(struct rk29_i2c_data *i2c)
 626 {
 627         unsigned long opr = readl(i2c->regs + I2C_OPR);
 628
 629         opr |= I2C_OPR_RESET_STATUS;
 630         writel(opr, i2c->regs + I2C_OPR);
 631
 632         udelay(10);
 633         opr = readl(i2c->regs + I2C_OPR);
 634         opr &= ~I2C_OPR_RESET_STATUS;
 635         writel(opr, i2c->regs + I2C_OPR);
 636
 637         rk29_i2c_clockrate(i2c);
 638
 639         rk29_i2c_disable_irqs(i2c);
 640         writel(0, i2c->regs + I2C_LCMR);
 641         writel(0, i2c->regs + I2C_LCMR);
 642
 643         opr = readl(i2c->regs + I2C_OPR);
 644         opr |= I2C_OPR_CORE_ENABLE;
 645         writel(opr, i2c->regs + I2C_OPR);
 646
 647         return;
 648 }
 649
 650 #ifdef CONFIG_CPU_FREQ
 651
 652 #define freq_to_i2c(_n) container_of(_n, struct rk29_i2c_data, freq_transition)
 653
 654 static int rk29_i2c_cpufreq_transition(struct notifier_block *nb,
 655                                           unsigned long val, void *data)
 656 {
 657         struct rk29_i2c_data *i2c = freq_to_i2c(nb);
 658         unsigned long flags;
 659         int delta_f;
 660         delta_f = clk_get_rate(i2c->clk) - i2c->i2c_rate;
 661
 662         if ((val == CPUFREQ_POSTCHANGE && delta_f < 0) ||
 663             (val == CPUFREQ_PRECHANGE && delta_f > 0))
 664         {
 665                 spin_lock_irqsave(&i2c->cmd_lock, flags);
 666                 rk29_i2c_clockrate(i2c);
 667                 spin_unlock_irqrestore(&i2c->cmd_lock, flags);
 668         }
 669         return 0;
 670 }
 671
 672 static inline int rk29_i2c_register_cpufreq(struct rk29_i2c_data *i2c)
 673 {
 674         if (i2c->adap.nr != 0)
 675                 return 0;
 676         i2c->freq_transition.notifier_call = rk29_i2c_cpufreq_transition;
 677
 678         return cpufreq_register_notifier(&i2c->freq_transition,
 679                                          CPUFREQ_TRANSITION_NOTIFIER);
 680 }
 681
 682 static inline void rk29_i2c_unregister_cpufreq(struct rk29_i2c_data *i2c)
 683 {
 684         if (i2c->adap.nr != 0)
 685                 return;
 686         cpufreq_unregister_notifier(&i2c->freq_transition,
 687                                     CPUFREQ_TRANSITION_NOTIFIER);
 688 }
 689
 690 #else
 691 static inline int rk29_i2c_register_cpufreq(struct rk29_i2c_data *i2c)
 692 {
 693         return 0;
 694 }
 695
 696 static inline void rk29_i2c_unregister_cpufreq(struct rk29_i2c_data *i2c)
 697 {
 698         return;
 699 }
 700 #endif
 701
 702 static int rk29_i2c_probe(struct platform_device *pdev)
 703 {
 704         struct rk29_i2c_data *i2c;
 705         struct rk29_i2c_platform_data *pdata = NULL;
 706         struct resource *res;
 707         int ret;
 708
 709         pdata = pdev->dev.platform_data;
 710         if (!pdata)
 711         {
 712                 i2c_err(&pdev->dev, "<error>no platform data\n");
 713                 return -EINVAL;
 714         }
 715         i2c = kzalloc(sizeof(struct rk29_i2c_data), GFP_KERNEL);
 716         if (!i2c)
 717         {
 718                 i2c_err(&pdev->dev, "<error>no memory for state\n");
 719                 return -ENOMEM;
 720         }
 721         init_completion(&i2c->cmd_complete);
 722         i2c->retry = RETRY_NUM;
 723         i2c->mode = pdata->mode;
 724         i2c->scl_rate = (pdata->scl_rate) ? pdata->scl_rate : 100000;
 725
 726         strlcpy(i2c->adap.name, DRV_NAME, sizeof(i2c->adap.name));
 727         i2c->adap.owner         = THIS_MODULE;
 728         i2c->adap.algo          = &rk29_i2c_algorithm;
 729         i2c->adap.class         = I2C_CLASS_HWMON;
 730         i2c->adap.nr            = pdata->bus_num;
 731     i2c->adap.retries   = 3;
 732     i2c->adap.timeout   = msecs_to_jiffies(500);
 733
 734         spin_lock_init(&i2c->cmd_lock);
 735
 736         i2c->dev = &pdev->dev;
 737
 738         i2c->clk = clk_get(&pdev->dev, "i2c");
 739         if (IS_ERR(i2c->clk)) {
 740                 i2c_err(&pdev->dev, "<error>cannot get clock\n");
 741                 ret = -ENOENT;
 742                 goto err_noclk;
 743         }
 744
 745         clk_enable(i2c->clk);
 746
 747         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 748         if (res == NULL) {
 749                 i2c_err(&pdev->dev, "<error>cannot find IO resource\n");
 750                 ret = -ENOENT;
 751                 goto err_clk;
 752         }
 753
 754         i2c->ioarea = request_mem_region(res->start, res->end - res->start + 1,
 755                                          pdev->name);
 756
 757         if (i2c->ioarea == NULL) {
 758                 i2c_err(&pdev->dev, "<error>cannot request IO\n");
 759                 ret = -ENXIO;
 760                 goto err_clk;
 761         }
 762
 763         i2c->regs = ioremap(res->start, res->end - res->start + 1);
 764
 765         if (i2c->regs == NULL) {
 766                 i2c_err(&pdev->dev, "<error>annot map IO\n");
 767                 ret = -ENXIO;
 768                 goto err_ioarea;
 769         }
 770         i2c->adap.algo_data = i2c;
 771         i2c->adap.dev.parent = &pdev->dev;
 772
 773         if(pdata->io_init)
 774         {
 775                 i2c->io_init = pdata->io_init;
 776                 pdata->io_init();
 777         }
 778
 779         i2c->irq = ret = platform_get_irq(pdev, 0);
 780         if (ret <= 0) {
 781                 i2c_err(&pdev->dev, "cannot find IRQ\n");
 782                 goto err_iomap;
 783         }
 784         ret = request_irq(i2c->irq, rk29_i2c_irq, IRQF_DISABLED,
 785                                 dev_name(&pdev->dev), i2c);
 786
 787         if (ret != 0) {
 788                 i2c_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);
 789                 goto err_iomap;
 790         }
 791         ret = rk29_i2c_register_cpufreq(i2c);
 792         if (ret < 0) {
 793                 i2c_err(&pdev->dev, "failed to register cpufreq notifier\n");
 794                 goto err_irq;
 795         }
 796
 797         ret = i2c_add_numbered_adapter(&i2c->adap);
 798         if (ret < 0) {
 799                 i2c_err(&pdev->dev, "failed to add bus to i2c core\n");
 800                 goto err_cpufreq;
 801         }
 802
 803         platform_set_drvdata(pdev, i2c);
 804         rk29_i2c_init_hw(i2c);
 805
 806         dev_info(&pdev->dev, "%s: RK29 I2C adapter\n", dev_name(&i2c->adap.dev));
 807         return 0;
 808
 809  err_cpufreq:
 810         rk29_i2c_unregister_cpufreq(i2c);
 811
 812  err_irq:
 813         free_irq(i2c->irq, i2c);
 814
 815  err_iomap:
 816         iounmap(i2c->regs);
 817
 818  err_ioarea:
 819         release_resource(i2c->ioarea);
 820         kfree(i2c->ioarea);
 821
 822  err_clk:
 823         clk_disable(i2c->clk);
 824         clk_put(i2c->clk);
 825
 826  err_noclk:
 827         kfree(i2c);
 828         return ret;
 829 }
 830
 831
 832 static int rk29_i2c_remove(struct platform_device *pdev)
 833 {
 834         struct rk29_i2c_data *i2c = platform_get_drvdata(pdev);
 835
 836
 837         rk29_i2c_deinit_hw(i2c);
 838         rk29_i2c_unregister_cpufreq(i2c);
 839
 840         i2c_del_adapter(&i2c->adap);
 841         free_irq(i2c->irq, i2c);
 842
 843         clk_disable(i2c->clk);
 844         clk_put(i2c->clk);
 845
 846         iounmap(i2c->regs);
 847
 848         release_resource(i2c->ioarea);
 849         kfree(i2c->ioarea);
 850         kfree(i2c);
 851
 852         return 0;
 853 }
 854
 855 #ifdef CONFIG_PM
 856 static int rk29_i2c_suspend_noirq(struct device *dev)
 857 {
 858         struct platform_device *pdev = to_platform_device(dev);
 859         struct rk29_i2c_data *i2c = platform_get_drvdata(pdev);
 860
 861         i2c->suspended = 1;
 862         return 0;
 863 }
 864
 865 static int rk29_i2c_resume_noirq(struct device *dev)
 866 {
 867         struct platform_device *pdev = to_platform_device(dev);
 868         struct rk29_i2c_data *i2c = platform_get_drvdata(pdev);
 869
 870         i2c->suspended = 0;
 871         rk29_i2c_init_hw(i2c);
 872
 873         return 0;
 874 }
 875
 876 static struct dev_pm_ops rk29_i2c_pm_ops = {
 877         .suspend_noirq  = rk29_i2c_suspend_noirq,
 878         .resume_noirq   = rk29_i2c_resume_noirq,
 879 };
 880 #endif
 881
 882 static struct platform_driver rk29_i2c_driver = {
 883         .probe          = rk29_i2c_probe,
 884         .remove         = rk29_i2c_remove,
 885         .driver         = {
 886                 .owner  = THIS_MODULE,
 887                 .name   = DRV_NAME,
 888 #ifdef CONFIG_PM
 889                 .pm     = &rk29_i2c_pm_ops,
 890 #endif
 891         },
 892 };
 893
 894 static int __init rk29_i2c_adap_init(void)
 895 {
 896 #if defined(CONFIG_ARCH_RK29) || defined(CONFIG_ARCH_RK30)
 897         wake_lock_init(&idlelock, WAKE_LOCK_IDLE, "i2c0");
 898 #endif
 899         return platform_driver_register(&rk29_i2c_driver);
 900 }
 901
 902 static void __exit rk29_i2c_adap_exit(void)
 903 {
 904         platform_driver_unregister(&rk29_i2c_driver);
 905 }
 906
 907 subsys_initcall(rk29_i2c_adap_init);
 908 module_exit(rk29_i2c_adap_exit);
 909
 910 MODULE_DESCRIPTION("Driver for RK29 I2C Bus");
 911 MODULE_AUTHOR("kfx, kfx@rock-chips.com");
 912 MODULE_LICENSE("GPL");