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