drivers/i2c/busses/i2c-rk2818.c

   1 /* drivers/i2c/busses/i2c_rk2818.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-rk2818.h"
  33 #define DRV_NAME        "rk2818_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 rk2818_error {
  46         RK2818_ERROR_NONE = 0,
  47         RK2818_ERROR_ARBITR_LOSE,
  48         RK2818_ERROR_UNKNOWN
  49 };
  50
  51 enum rk2818_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 rk2818_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 rk2818_event               cmd_event;
  82         enum rk2818_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 rk2818_i2c_init_hw(struct rk2818_i2c_data *i2c);
  92
  93 static inline void rk2818_i2c_disable_irqs(struct rk2818_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 rk2818_i2c_enable_irqs(struct rk2818_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 rk2818_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  rk2818_i2c_clockrate(struct rk2818_i2c_data *i2c)
 135 {
 136         struct rk2818_i2c_platform_data *pdata = i2c->dev->platform_data;
 137         unsigned int rem = 0, exp = 0;
 138         unsigned long scl_rate, real_rate = 0, tmp;
 139
 140         i2c->i2c_rate = clk_get_rate(i2c->clk);
 141
 142         scl_rate = (i2c->scl_rate) ? i2c->scl_rate : ((pdata->scl_rate)? pdata->scl_rate:100000);
 143
 144         rk2818_i2c_calcdivisor(i2c->i2c_rate, scl_rate, &real_rate, &rem, &exp);
 145
 146         tmp = readl(i2c->regs + I2C_OPR);
 147         tmp |= exp;
 148         tmp |= rem<<I2CCDVR_EXP_BITS;
 149         writel(tmp, i2c->regs + I2C_OPR);
 150         if(real_rate > 400000)
 151                 dev_warn(i2c->dev, "i2c_rate[%luKhz], scl_rate[%luKhz], real_rate[%luKhz] > 400Khz\n",
 152                                 i2c->i2c_rate/1000, scl_rate/1000, real_rate/1000);
 153         else
 154                 i2c_dbg(i2c->dev, "i2c_rate[%luKhz], scl_rate[%luKhz], real_rate[%luKhz]\n",
 155                                 i2c->i2c_rate/1000, scl_rate/1000, real_rate/1000);
 156         return;
 157 }
 158 static int rk2818_event_occurred(struct rk2818_i2c_data *i2c)
 159 {
 160         unsigned long isr;
 161
 162         isr = readl(i2c->regs + I2C_ISR);
 163         i2c_dbg(i2c->dev,"event occurred, isr = %lx\n", isr);
 164         if(isr & I2C_ISR_ARBITR_LOSE)
 165         {
 166                 isr &= ~I2C_ISR_ARBITR_LOSE;
 167                 writel(isr, i2c->regs + I2C_ISR);
 168                 i2c->cmd_err = RK2818_ERROR_ARBITR_LOSE;
 169                 dev_err(i2c->dev, "<error>arbitration loss\n");
 170                 return 1;
 171         }
 172
 173         switch(i2c->cmd_event)
 174         {
 175                 case RK2818_EVENT_MTX_RCVD_ACK:
 176                         if(isr & I2C_ISR_MTX_RCVD_ACK)
 177                         {
 178                                 isr &= ~I2C_ISR_MTX_RCVD_ACK;
 179                                 writel(isr, i2c->regs + I2C_ISR);
 180                                 return 1;
 181                         }
 182                 break;
 183                 case RK2818_EVENT_MRX_NEED_ACK:
 184                         if(isr & I2C_ISR_MRX_NEED_ACK)
 185                         {
 186                                 isr &= ~I2C_ISR_MRX_NEED_ACK;
 187                                 writel(isr, i2c->regs + I2C_ISR);
 188                                 return 1;
 189                         }
 190                         break;
 191                 default:
 192                         break;
 193         }
 194         i2c->cmd_err = RK2818_ERROR_UNKNOWN;
 195         return 0;
 196 }
 197
 198 static irqreturn_t rk2818_i2c_irq(int irq, void *data)
 199 {
 200         struct rk2818_i2c_data *i2c = (struct rk2818_i2c_data *)data;
 201         int res;
 202
 203         rk2818_i2c_disable_irqs(i2c);
 204         spin_lock(&i2c->cmd_lock);
 205         res = rk2818_event_occurred(i2c);
 206         if(res)
 207         //if(res || i2c->cmd_err != RK2818_ERROR_NONE)
 208                 complete(&i2c->cmd_complete);
 209         spin_unlock(&i2c->cmd_lock);
 210         return IRQ_HANDLED;
 211 }
 212 static int wait_for_completion_poll_timeout(struct rk2818_i2c_data *i2c, unsigned long timeout)
 213 {
 214         unsigned int time = RK2818_DELAY_TIME;
 215         int res;
 216
 217         while(!time_after(jiffies, timeout))
 218         {
 219                 res = rk2818_event_occurred(i2c);
 220                 if(res)
 221                 //if(res || (i2c->cmd_err != RK2818_ERROR_NONE && i2c->cmd_err != RK2818_ERROR_UNKNOWN))
 222                         return 1;
 223                 udelay(time);
 224                 time *= 2;
 225         }
 226         return 0;
 227
 228 }
 229 static int rk2818_wait_event(struct rk2818_i2c_data *i2c,
 230                                         enum rk2818_event mr_event)
 231 {
 232         int ret = 0;
 233
 234         if(unlikely(irqs_disabled()))
 235         {
 236                 dev_err(i2c->dev, "irqs are disabled on this system!\n");
 237                 return -EIO;
 238         }
 239         spin_lock_irq(&i2c->cmd_lock);
 240         i2c->cmd_err = RK2818_ERROR_NONE;
 241         i2c->cmd_event = mr_event;
 242
 243         init_completion(&i2c->cmd_complete);
 244
 245         spin_unlock_irq(&i2c->cmd_lock);
 246
 247         rk2818_i2c_enable_irqs(i2c);
 248         if(i2c->mode == I2C_MODE_IRQ)
 249                 ret = wait_for_completion_interruptible_timeout(&i2c->cmd_complete,
 250                                                                 RK2818_I2C_TIMEOUT);
 251         else
 252                 ret = wait_for_completion_poll_timeout(i2c, RK2818_I2C_TIMEOUT);
 253
 254         if(ret < 0)
 255         {
 256                 dev_err(i2c->dev, "i2c wait for event %04x, retrun %d \n", mr_event, ret);
 257                 return ret;
 258         }
 259         if(ret == 0)
 260         {
 261                 return -ETIMEDOUT;
 262         }
 263         return 0;
 264 }
 265
 266 static int rk2818_wait_while_busy(struct rk2818_i2c_data *i2c)
 267 {
 268         unsigned long timeout = jiffies + RK2818_I2C_TIMEOUT;
 269         unsigned long lsr;
 270         unsigned int time = RK2818_DELAY_TIME;
 271
 272         while(!time_after(jiffies, timeout))
 273         {
 274                 lsr = readl(i2c->regs + I2C_LSR);
 275                 if(!(lsr & I2C_LSR_BUSY))
 276                         return 0;
 277                 udelay(time);
 278                 time *= 2;
 279         }
 280         return -ETIMEDOUT;
 281 }
 282 static int rk2818_i2c_stop(struct rk2818_i2c_data *i2c)
 283 {
 284         unsigned long timeout = jiffies + RK2818_I2C_TIMEOUT;
 285         unsigned int time = RK2818_DELAY_TIME;
 286
 287         writel(I2C_LCMR_STOP|I2C_LCMR_RESUME, i2c->regs + I2C_LCMR);
 288         while(!time_after(jiffies, timeout))
 289         {
 290                 if(!(readl(i2c->regs + I2C_LCMR) & I2C_LCMR_STOP))
 291                 {
 292                         i2c_dbg(i2c->dev, "i2c stop successfully\n");
 293                         return 0;
 294                 }
 295                 udelay(time);
 296                 time *= 2;
 297         }
 298         return -ETIMEDOUT;
 299
 300 }
 301 static int rk2818_send_2nd_addr(struct rk2818_i2c_data *i2c,
 302                                                 struct i2c_msg *msg, int start)
 303 {
 304         int ret = 0;
 305         unsigned long addr_2nd = msg->addr & 0xff;
 306         unsigned long conr = readl(i2c->regs + I2C_CONR);
 307
 308         conr |= I2C_CONR_MTX_MODE;
 309         //conr &= I2C_CONR_ACK;
 310         writel(conr, i2c->regs + I2C_CONR);
 311
 312         i2c_dbg(i2c->dev, "i2c send addr_2nd: %lx\n", addr_2nd);
 313         writel(addr_2nd, i2c->regs + I2C_MTXR);
 314         writel(I2C_LCMR_RESUME, i2c->regs + I2C_LCMR);
 315         if((ret = rk2818_wait_event(i2c, RK2818_EVENT_MTX_RCVD_ACK)) != 0)
 316         {
 317                 dev_err(i2c->dev, "after sent addr_2nd, i2c wait for ACK timeout\n");
 318                 return ret;
 319         }
 320         return ret;
 321 }
 322 static int rk2818_send_address(struct rk2818_i2c_data *i2c,
 323                                                 struct i2c_msg *msg, int start)
 324 {
 325         unsigned long addr_1st;
 326         unsigned long conr = readl(i2c->regs + I2C_CONR);
 327         int ret = 0;
 328
 329         if(msg->flags & I2C_M_TEN)
 330                 addr_1st = (0xf0 | (((unsigned long) msg->addr & 0x300) >> 7)) & 0xff;
 331         else
 332                 addr_1st = ((msg->addr << 1) & 0xff);
 333
 334         if (msg->flags & I2C_M_RD)
 335                 addr_1st |= 0x01;
 336         else
 337                 addr_1st &= (~0x01);
 338
 339         conr |= I2C_CONR_MTX_MODE;
 340         //conr &= I2C_CONR_ACK;
 341         writel(conr, i2c->regs + I2C_CONR);
 342         i2c_dbg(i2c->dev, "i2c send addr_1st: %lx\n", addr_1st);
 343
 344         writel(addr_1st, i2c->regs + I2C_MTXR);
 345
 346         if (start)
 347         {
 348                 if((ret = rk2818_wait_while_busy(i2c)) != 0)
 349                 {
 350                         dev_err(i2c->dev, "i2c is busy, when send address\n");
 351                         return ret;
 352                 }
 353                 writel(I2C_LCMR_START, i2c->regs + I2C_LCMR);
 354         }
 355         else
 356                 writel(I2C_LCMR_START|I2C_LCMR_RESUME, i2c->regs + I2C_LCMR);
 357
 358         if((ret = rk2818_wait_event(i2c, RK2818_EVENT_MTX_RCVD_ACK)) != 0)
 359         {
 360                 dev_err(i2c->dev, "after sent addr_1st, i2c wait for ACK timeout\n");
 361                 return ret;
 362         }
 363         if(start && (msg->flags & I2C_M_TEN))
 364                 ret = rk2818_send_2nd_addr(i2c, msg, start);
 365         return ret;
 366 }
 367
 368 static int rk2818_i2c_send_msg(struct rk2818_i2c_data *i2c, struct i2c_msg *msg)
 369 {
 370         int i, ret = 0;
 371         unsigned long conr = readl(i2c->regs + I2C_CONR);
 372
 373         conr = readl(i2c->regs + I2C_CONR);
 374         conr |= I2C_CONR_MTX_MODE;
 375         writel(conr, i2c->regs + I2C_CONR);
 376         for(i = 0; i < msg->len; i++)
 377         {
 378                 i2c_dbg(i2c->dev, "i2c send buf[%d]: %x\n", i, msg->buf[i]);
 379                 writel(msg->buf[i], i2c->regs + I2C_MTXR);
 380                 /*
 381                 conr = readl(i2c->regs + I2C_CONR);
 382                 conr &= I2C_CONR_ACK;
 383                 writel(conr, i2c->regs + I2C_CONR);
 384                 */
 385                 writel(I2C_LCMR_RESUME, i2c->regs + I2C_LCMR);
 386
 387                 if((ret = rk2818_wait_event(i2c, RK2818_EVENT_MTX_RCVD_ACK)) != 0)
 388                         return ret;
 389         }
 390         return ret;
 391 }
 392 static int rk2818_i2c_recv_msg(struct rk2818_i2c_data *i2c, struct i2c_msg *msg)
 393 {
 394         int i, ret = 0;
 395         unsigned long conr = readl(i2c->regs + I2C_CONR);
 396
 397         conr = readl(i2c->regs + I2C_CONR);
 398         conr &= I2C_CONR_MRX_MODE;
 399         writel(conr, i2c->regs + I2C_CONR);
 400
 401         for(i = 0; i < msg->len; i++)
 402         {
 403                 writel(I2C_LCMR_RESUME, i2c->regs + I2C_LCMR);
 404                 if((ret = rk2818_wait_event(i2c, RK2818_EVENT_MRX_NEED_ACK)) != 0)
 405                         return ret;
 406                 conr = readl(i2c->regs + I2C_CONR);
 407                 conr &= I2C_CONR_ACK;
 408                 writel(conr, i2c->regs + I2C_CONR);
 409                 msg->buf[i] = (uint8_t)readl(i2c->regs + I2C_MRXR);
 410                 i2c_dbg(i2c->dev, "i2c recv >>>>>>>>>>>> buf[%d]: %x\n", i, msg->buf[i]);
 411         }
 412         return ret;
 413 }
 414 static int rk2818_xfer_msg(struct i2c_adapter *adap,
 415                                                  struct i2c_msg *msg, int start, int stop)
 416 {
 417         struct rk2818_i2c_data *i2c = (struct rk2818_i2c_data *)adap->algo_data;
 418         unsigned long conr = readl(i2c->regs + I2C_CONR);
 419         int ret = 0;
 420
 421
 422         if(msg->len == 0)
 423         {
 424                 ret = -EINVAL;
 425                 dev_err(i2c->dev, "<error>msg->len = %d\n", msg->len);
 426                 goto exit;
 427         }
 428
 429         if((ret = rk2818_send_address(i2c, msg, start))!= 0)
 430         {
 431                 dev_err(i2c->dev, "<error>rk2818_send_address timeout\n");
 432                 goto exit;
 433         }
 434         if(msg->flags & I2C_M_RD)
 435         {
 436                 if((ret = rk2818_i2c_recv_msg(i2c, msg)) != 0)
 437                 {
 438                         dev_err(i2c->dev, "<error>rk2818_i2c_recv_msg timeout\n");
 439                         goto exit;
 440                 }
 441         }
 442         else
 443         {
 444                 if((ret = rk2818_i2c_send_msg(i2c, msg)) != 0)
 445                 {
 446                         dev_err(i2c->dev, "<error>rk2818_i2c_send_msg timeout\n");
 447                         goto exit;
 448                 }
 449         }
 450
 451 exit:
 452         if(stop)
 453         {
 454                 conr = readl(i2c->regs + I2C_CONR);
 455                 conr |= I2C_CONR_NAK;
 456                 writel(conr, i2c->regs + I2C_CONR);
 457                 if((ret = rk2818_i2c_stop(i2c)) != 0)
 458                 {
 459                         dev_err(i2c->dev, "<error>rk2818_i2c_stop timeout\n");
 460                 }
 461
 462         }
 463         return ret;
 464
 465 }
 466
 467 static int rk2818_i2c_xfer(struct i2c_adapter *adap,
 468                         struct i2c_msg *msgs, int num)
 469 {
 470         int ret = -1;
 471         int i;
 472         struct rk2818_i2c_data *i2c = (struct rk2818_i2c_data *)adap->algo_data;
 473         unsigned long conr = readl(i2c->regs + I2C_CONR);
 474
 475         if(i2c->suspended ==1)
 476                 return -EIO;
 477         if(msgs[0].scl_rate <= 400000 && msgs[0].scl_rate > 0)
 478                 i2c->scl_rate = msgs[0].scl_rate;
 479         else
 480                 i2c->scl_rate = 400000;
 481
 482         conr |= I2C_CONR_MPORT_ENABLE;
 483         writel(conr, i2c->regs + I2C_CONR);
 484
 485         rk2818_i2c_init_hw(i2c);
 486
 487         conr = readl(i2c->regs + I2C_CONR);
 488         conr &= I2C_CONR_ACK;
 489         writel(conr, i2c->regs + I2C_CONR);
 490
 491         for (i = 0; i < num; i++)
 492         {
 493                 ret = rk2818_xfer_msg(adap, &msgs[i], (i == 0), (i == (num - 1)));
 494                 if (ret != 0)
 495                 {
 496                         num = ret;
 497                         dev_err(i2c->dev, "rk2818_xfer_msg error, ret = %d\n", ret);
 498                         break;
 499                 }
 500         }
 501         conr = readl(i2c->regs + I2C_CONR);
 502         conr &= I2C_CONR_MPORT_DISABLE;
 503         writel(conr, i2c->regs + I2C_CONR);
 504         return num;
 505 }
 506
 507 static u32 rk2818_i2c_func(struct i2c_adapter *adap)
 508 {
 509         return I2C_FUNC_I2C | I2C_FUNC_10BIT_ADDR;
 510 }
 511
 512 static const struct i2c_algorithm rk2818_i2c_algorithm = {
 513         .master_xfer            = rk2818_i2c_xfer,
 514         .functionality          = rk2818_i2c_func,
 515 };
 516
 517
 518 static void rk2818_i2c_init_hw(struct rk2818_i2c_data *i2c)
 519 {
 520         unsigned long lcmr = 0x00000000;
 521
 522         unsigned long opr = readl(i2c->regs + I2C_OPR);
 523         opr |= I2C_OPR_RESET_STATUS;
 524         writel(opr, i2c->regs + I2C_OPR);
 525
 526         writel(lcmr, i2c->regs + I2C_LCMR);
 527
 528         rk2818_i2c_disable_irqs(i2c);
 529
 530         rk2818_i2c_clockrate(i2c);
 531
 532         opr = readl(i2c->regs + I2C_OPR);
 533         opr |= I2C_OPR_CORE_ENABLE;
 534         writel(opr, i2c->regs + I2C_OPR);
 535
 536         return;
 537 }
 538
 539 #ifdef CONFIG_CPU_FREQ
 540
 541 #define freq_to_i2c(_n) container_of(_n, struct rk2818_i2c_data, freq_transition)
 542
 543 static int rk2818_i2c_cpufreq_transition(struct notifier_block *nb,
 544                                           unsigned long val, void *data)
 545 {
 546         struct rk2818_i2c_data *i2c = freq_to_i2c(nb);
 547         unsigned long flags;
 548         int delta_f;
 549         delta_f = clk_get_rate(i2c->clk) - i2c->i2c_rate;
 550
 551         if ((val == CPUFREQ_POSTCHANGE && delta_f < 0) ||
 552             (val == CPUFREQ_PRECHANGE && delta_f > 0))
 553         {
 554                 spin_lock_irqsave(&i2c->cmd_lock, flags);
 555                 rk2818_i2c_clockrate(i2c);
 556                 spin_unlock_irqrestore(&i2c->cmd_lock, flags);
 557         }
 558         return 0;
 559 }
 560
 561 static inline int rk2818_i2c_register_cpufreq(struct rk2818_i2c_data *i2c)
 562 {
 563         i2c->freq_transition.notifier_call = rk2818_i2c_cpufreq_transition;
 564
 565         return cpufreq_register_notifier(&i2c->freq_transition,
 566                                          CPUFREQ_TRANSITION_NOTIFIER);
 567 }
 568
 569 static inline void rk2818_i2c_unregister_cpufreq(struct rk2818_i2c_data *i2c)
 570 {
 571         cpufreq_unregister_notifier(&i2c->freq_transition,
 572                                     CPUFREQ_TRANSITION_NOTIFIER);
 573 }
 574
 575 #else
 576 static inline int rk2818_i2c_register_cpufreq(struct rk2818_i2c_data *i2c)
 577 {
 578         return 0;
 579 }
 580
 581 static inline void rk2818_i2c_unregister_cpufreq(struct rk2818_i2c_data *i2c)
 582 {
 583         return;
 584 }
 585 #endif
 586 static int rk2818_i2c_probe(struct platform_device *pdev)
 587 {
 588         struct rk2818_i2c_data *i2c;
 589         struct rk2818_i2c_platform_data *pdata;
 590         struct resource *res;
 591         int ret;
 592
 593         pdata = pdev->dev.platform_data;
 594         if (!pdata)
 595         {
 596                 dev_err(&pdev->dev, "<error>no platform data\n");
 597                 return -EINVAL;
 598         }
 599         i2c = kzalloc(sizeof(struct rk2818_i2c_data), GFP_KERNEL);
 600         if (!i2c)
 601         {
 602                 dev_err(&pdev->dev, "<error>no memory for state\n");
 603                 return -ENOMEM;
 604         }
 605         i2c->mode = pdata->mode;
 606         i2c->scl_rate = (pdata->scl_rate) ? pdata->scl_rate : 100000;
 607
 608         strlcpy(i2c->adap.name, DRV_NAME, sizeof(i2c->adap.name));
 609         i2c->adap.owner         = THIS_MODULE;
 610         i2c->adap.algo          = &rk2818_i2c_algorithm;
 611         i2c->adap.class         = I2C_CLASS_HWMON;
 612         spin_lock_init(&i2c->cmd_lock);
 613
 614         i2c->dev = &pdev->dev;
 615
 616         i2c->clk = clk_get(&pdev->dev, "i2c");
 617         if (IS_ERR(i2c->clk)) {
 618                 dev_err(&pdev->dev, "<error>cannot get clock\n");
 619                 ret = -ENOENT;
 620                 goto err_noclk;
 621         }
 622
 623         clk_enable(i2c->clk);
 624
 625         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 626         if (res == NULL) {
 627                 dev_err(&pdev->dev, "<error>cannot find IO resource\n");
 628                 ret = -ENOENT;
 629                 goto err_clk;
 630         }
 631
 632         i2c->ioarea = request_mem_region(res->start, res->end - res->start + 1,
 633                                          pdev->name);
 634
 635         if (i2c->ioarea == NULL) {
 636                 dev_err(&pdev->dev, "<error>cannot request IO\n");
 637                 ret = -ENXIO;
 638                 goto err_clk;
 639         }
 640
 641         i2c->regs = ioremap(res->start, res->end - res->start + 1);
 642
 643         if (i2c->regs == NULL) {
 644                 dev_err(&pdev->dev, "<error>annot map IO\n");
 645                 ret = -ENXIO;
 646                 goto err_ioarea;
 647         }
 648         i2c->adap.algo_data = i2c;
 649         i2c->adap.dev.parent = &pdev->dev;
 650
 651         if(pdata->io_init)
 652                 pdata->io_init();
 653
 654         rk2818_i2c_init_hw(i2c);
 655
 656         i2c->irq = ret = platform_get_irq(pdev, 0);
 657         if (ret <= 0) {
 658                 dev_err(&pdev->dev, "cannot find IRQ\n");
 659                 goto err_iomap;
 660         }
 661         if(i2c->mode == I2C_MODE_IRQ)
 662         {
 663                 ret = request_irq(i2c->irq, rk2818_i2c_irq, IRQF_DISABLED,
 664                                 dev_name(&pdev->dev), i2c);
 665
 666                 if (ret != 0) {
 667                         dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);
 668                         goto err_iomap;
 669                 }
 670         }
 671         ret = rk2818_i2c_register_cpufreq(i2c);
 672         if (ret < 0) {
 673                 dev_err(&pdev->dev, "failed to register cpufreq notifier\n");
 674                 goto err_irq;
 675         }
 676
 677         i2c->adap.nr = pdata->bus_num;
 678         ret = i2c_add_numbered_adapter(&i2c->adap);
 679         if (ret < 0) {
 680                 dev_err(&pdev->dev, "failed to add bus to i2c core\n");
 681                 goto err_cpufreq;
 682         }
 683
 684         platform_set_drvdata(pdev, i2c);
 685
 686         dev_info(&pdev->dev, "%s: RK2818 I2C adapter\n", dev_name(&i2c->adap.dev));
 687         return 0;
 688
 689  err_cpufreq:
 690         rk2818_i2c_unregister_cpufreq(i2c);
 691
 692  err_irq:
 693         if(i2c->mode == I2C_MODE_IRQ)
 694                 free_irq(i2c->irq, i2c);
 695
 696  err_iomap:
 697         iounmap(i2c->regs);
 698
 699  err_ioarea:
 700         release_resource(i2c->ioarea);
 701         kfree(i2c->ioarea);
 702
 703  err_clk:
 704         clk_disable(i2c->clk);
 705         clk_put(i2c->clk);
 706
 707  err_noclk:
 708         kfree(i2c);
 709         return ret;
 710 }
 711
 712
 713 static int rk2818_i2c_remove(struct platform_device *pdev)
 714 {
 715         struct rk2818_i2c_data *i2c = platform_get_drvdata(pdev);
 716
 717         rk2818_i2c_unregister_cpufreq(i2c);
 718
 719         i2c_del_adapter(&i2c->adap);
 720          if(i2c->mode == I2C_MODE_IRQ)
 721                 free_irq(i2c->irq, i2c);
 722
 723         clk_disable(i2c->clk);
 724         clk_put(i2c->clk);
 725
 726         iounmap(i2c->regs);
 727
 728         release_resource(i2c->ioarea);
 729         kfree(i2c->ioarea);
 730         kfree(i2c);
 731
 732         return 0;
 733 }
 734
 735 #ifdef CONFIG_PM
 736 static int rk2818_i2c_suspend(struct platform_device *pdev, pm_message_t state)
 737 {
 738         struct rk2818_i2c_data *i2c = platform_get_drvdata(pdev);
 739
 740         i2c->suspended = 1;
 741         return 0;
 742 }
 743 static int rk2818_i2c_resume(struct platform_device *pdev)
 744 {
 745         struct rk2818_i2c_data *i2c = platform_get_drvdata(pdev);
 746
 747         i2c->suspended = 0;
 748         rk2818_i2c_init_hw(i2c);
 749
 750         return 0;
 751 }
 752 #else
 753 #define rk2818_i2c_suspend              NULL
 754 #define rk2818_i2c_resume               NULL
 755 #endif
 756
 757
 758 static struct platform_driver rk2818_i2c_driver = {
 759         .probe          = rk2818_i2c_probe,
 760         .remove         = rk2818_i2c_remove,
 761         .suspend        = rk2818_i2c_suspend,
 762         .resume         = rk2818_i2c_resume,
 763         .driver         = {
 764                 .owner  = THIS_MODULE,
 765                 .name   = DRV_NAME,
 766         },
 767 };
 768
 769 static int __init rk2818_i2c_adap_init(void)
 770 {
 771         return platform_driver_register(&rk2818_i2c_driver);
 772 }
 773
 774 static void __exit rk2818_i2c_adap_exit(void)
 775 {
 776         platform_driver_unregister(&rk2818_i2c_driver);
 777 }
 778
 779 subsys_initcall(rk2818_i2c_adap_init);
 780 module_exit(rk2818_i2c_adap_exit);
 781
 782 MODULE_DESCRIPTION("Driver for RK2818 I2C Bus");
 783 MODULE_AUTHOR("kfx, kfx@rock-chips.com");
 784 MODULE_LICENSE("GPL");